Graph Fusion Module Overview

• Graph Fusion Module is a component that integrates heterogeneous information—such as modalities, temporal snapshots, and feature groups—using graph-based representations.
• It encompasses diverse mechanisms including multi-graph structural fusion, feature-to-graph projection, cross-modal graph attention, and hypergraph aggregation.
• The module is strategically integrated within larger architectures for tasks like emotion recognition and traffic forecasting, offering structural bias and efficient information propagation.

A graph fusion module is a model component that uses graph structure to integrate heterogeneous information—modalities, temporal snapshots, relation types, region prototypes, or latent feature groups—into a task-specific representation. The cited literature suggests that the term does not denote a single canonical operator; rather, it spans explicit adjacency fusion, graph-based feature fusion, latent graph reasoning, hypergraph aggregation, and even compiler-level fusion of graph primitives. In multimodal conversational emotion recognition, it couples cross-modal alignment with dialogue-graph reasoning (Feng et al., 25 Jan 2025). In traffic forecasting, it constructs a single spatial-temporal fusion graph from spatial adjacency, temporal similarity, and temporal connectivity (Li et al., 2020). In multi-network learning, it can mean learning edge weights for a fused graph from node-level and association-level attention before running a downstream GCN (Kesimoglu et al., 2023).

1. Scope, terminology, and recurring forms

The cited literature suggests four recurring forms of graph fusion modules. First, some methods fuse multiple graphs into one graph and then perform message passing; STFGNN builds $A_{STFG}$ from $A_{SG}$, $A_{TG}$, and $A_{TC}$, while GRAF computes fused edge scores from node-level and association-level attentions (Li et al., 2020, Kesimoglu et al., 2023). Second, some methods convert non-graph features into graph nodes and use graph propagation as the fusion mechanism; AGCM turns high-level feature maps into prototype nodes, and Project-and-Fuse projects RGB and depth features into shared region nodes before GCN reasoning (Lee et al., 2023, Jiang et al., 31 Jan 2025). Third, some methods treat modalities or streams themselves as graph entities; MERC-GCN, ARPGNet, the speech emotion graph model, SMORE, and GraphFusion3D all use graph structure to mediate multimodal or multi-view interaction rather than simple concatenation (Feng et al., 25 Jan 2025, Li et al., 27 Nov 2025, Liu et al., 2024, Ong et al., 2024, Mia et al., 2 Dec 2025). Fourth, some work generalizes pairwise graphs to hypergraphs or to compiler-level fusion of graph primitives; LCNet’s MHF uses incidence-based hypergraph propagation, whereas GraFS fuses declarative graph analytics into reductions over paths, mappings over vertices, and reductions over vertices (Ma et al., 17 Jun 2026, Houshmand et al., 2020).

Pattern	Representative mechanism	Example papers
Multi-graph structural fusion	Build fused adjacency from several graphs	(Li et al., 2020, Kesimoglu et al., 2023, Wu et al., 2022)
Feature-to-graph fusion	Project features into nodes, reason on graph, re-project	(Lee et al., 2023, Jiang et al., 31 Jan 2025, Ahmed et al., 27 Jan 2026)
Cross-modal graph fusion	Modalities or streams interact through graph attention/convolution	(Feng et al., 25 Jan 2025, Li et al., 27 Nov 2025, Ong et al., 2024)
Hypergraph or systems-level fusion	Hyperedge propagation or fusion of graph primitives	(Ma et al., 17 Jun 2026, Houshmand et al., 2020)

A common misconception is to equate graph fusion with feature concatenation. Several papers explicitly position their modules against concatenation, summation, or independent processing, arguing that those schemes ignore heterogeneous relations, amplify noise, or miss structural dependencies (Xia et al., 2024, Liu et al., 2024, Ong et al., 2024).

2. Construction of nodes, edges, and fused topologies

Graph fusion modules differ first in what they choose as nodes. In dialogue emotion recognition, nodes are utterances $v_i$ initialized by multimodal context-aware features $g_i$, and edges connect neighbors in a temporal window with adaptive weights $\alpha_{ij}$ computed by similarity-based attention; the experiments set past and future windows to 10 (Feng et al., 25 Jan 2025). In STFGNN, the node set is time-expanded: $A_{STFG} \in \mathbb{R}^{KN \times KN}$ places $A_{SG}+A_{TG}$ on diagonal blocks and temporal-connectivity edges across adjacent time blocks, so each node is effectively a road–time pair rather than only a road (Li et al., 2020). In AGCM, nodes are prototype features $P = I S^T$ obtained by attention-based masked average pooling of a feature map, and a KNN graph is built in feature space before affinity refinement $A_{SG}$0 (Lee et al., 2023). In ARPGNet, the fusion graph has $A_{SG}$1 nodes, one appearance node and one relation node per frame, with edges defined by the temporal response scope (TRS) across and within streams (Li et al., 27 Nov 2025).

Other designs make node construction an explicit part of the inductive bias. Project-and-Fuse generates a projection matrix $A_{SG}$2 from RGB features and reuses the same $A_{SG}$3 to project depth features, so the texture branch defines the region partition and geometry is injected into the same nodes (Jiang et al., 31 Jan 2025). TFFM pools decoder features to a coarse grid, treats pooled cells as latent graph nodes, and connects them by cosine-similarity kNN, making the graph content-driven rather than image-grid-driven (Ahmed et al., 27 Jan 2026). GraphFusion3D defines nodes as object proposals or proposal points with 3D positions and proposal features, then builds multi-scale k-NN graphs at $A_{SG}$4 (Mia et al., 2 Dec 2025). KG-FiD defines nodes as retrieved passages, but edges come from a knowledge graph: two passages are connected if their Wikipedia articles map to Wikidata entities that are directly linked (Yu et al., 2021).

The cited literature also shows that “fusion” can happen at the topology level itself. GRAF computes

$A_{SG}$5

thereby producing a weighted fused adjacency from multiple association graphs (Kesimoglu et al., 2023). MGFN fuses a time series of mobility graphs by clustering them with Mobility Graph Distance, whose components include mean and variance of edge weights, directional imbalance, spatial structure labels, and temporal proximity, and then aggregating graphs inside each cluster into mobility patterns (Wu et al., 2022). This suggests that the graph fusion module is often defined as much by graph construction as by downstream propagation.

3. Fusion operators and message passing mechanisms

Once nodes and edges are defined, graph fusion modules differ in how they aggregate information. A first family uses attention as the fusion operator. MERC-GCN applies pairwise co-attention transformers between modalities, concatenates cross-modal outputs with unimodal features, and then uses BiGRU before adaptive GCN reasoning (Feng et al., 25 Jan 2025). ARPGNet uses GAT over a fusion graph whose neighborhoods are determined by TRS, so each frame-level node aggregates both intra-stream temporal context and inter-stream complementary information (Li et al., 27 Nov 2025). The speech emotion graph model learns multi-dimensional edge features through AVCR and AVVR cross-attention, so edge representations encode vertex–context and vertex–vertex relations rather than only scalar edge weights (Liu et al., 2024). CaEGCN blends CAE and GAE features as $A_{SG}$6 and then applies multi-head cross-attention to obtain $A_{SG}$7, which becomes the input to the next GCN layer (Huo et al., 2021).

A second family uses graph convolution or graph-like propagation after fusion. STFGNN applies a GLU-style graph multiplication block,

$A_{SG}$8

so fusion is encoded structurally in $A_{SG}$9 and exploited by repeated propagation (Li et al., 2020). AGCM first computes adaptive channel weights $A_{TG}$0, forms $A_{TG}$1, and then performs graph fusion by

$A_{TG}$2

which is attention-like message passing over prototypes (Lee et al., 2023). TFFM uses masked GAT on a latent vessel graph, then fuses graph-enhanced features back with CNN features via channel attention, spatial attention, vesselness gating, and a gated residual connection (Ahmed et al., 27 Jan 2026). GraphFusion3D uses dynamic graph attention convolution in which messages are weighted jointly by feature attention $A_{TG}$3 and spatial weights $A_{TG}$4 across several neighborhood scales, before residual fusion across scales (Mia et al., 2 Dec 2025).

A third family broadens the notion of graph fusion beyond pairwise graph neural propagation. LCNet’s MHF defines a hypergraph with incidence matrix $A_{TG}$5 and normalized operator

$A_{TG}$6

so each node aggregates from hyperedges linking groups of similar foreground or background tokens rather than only pairwise neighbors (Ma et al., 17 Jun 2026). GraphTransfer, by contrast, aligns feature spaces through score-level fusion rather than adjacency learning: it defines $A_{TG}$7, $A_{TG}$8, and $A_{TG}$9, then minimizes discrepancies between these interaction scores (Xia et al., 2024). GraFS is further removed from neural message passing: its “fusion” consists of semantics-preserving transformations that collapse sequences of graph analytics into fewer reductions over paths, mappings over vertices, and reductions over vertices (Houshmand et al., 2020). This suggests that a graph fusion module can be defined either by how it propagates information or by how it rewrites multiple graph computations into a shared primitive.

4. Architectural integration patterns

Graph fusion modules are rarely standalone; they typically sit between a feature extractor and a prediction head. MERC-GCN places cross-modal context fusion before the adaptive graph convolutional encoding module, then concatenates sequential and graph features as $A_{TC}$0 before attention and emotion classification (Feng et al., 25 Jan 2025). Project-and-Fuse adopts an explicit pixel–node–pixel pipeline after dual DeepLabV3+ backbones: projection to region nodes, GCN reasoning, and re-projection to pixels for semantic segmentation (Jiang et al., 31 Jan 2025). AGCM is inserted only on the two highest-level skip connections of a VGG16 encoder–decoder, using graph-refined correlation maps as additional decoder channels (Lee et al., 2023). TFFM attaches graph reasoning to every decoder level of an EfficientNet-B0 U-Net++ with Attention Gates, then adaptively integrates graph-enhanced features back into the convolutional stream (Ahmed et al., 27 Jan 2026).

A second integration pattern is parallel-stream mutual enhancement. ARPGNet maintains a CNN appearance stream and a GNN relation stream, then lets the parallel graph attention fusion module jointly model inter-stream complementarity and temporal dynamics before MLP classification (Li et al., 27 Nov 2025). SMORE couples Spectrum Modality Fusion, Multi-modal Graph Learning, and a Modality-Aware Preference Module; graph propagation occurs on modality-specific and fusion item graphs, and the resulting modality-side features are combined with behavioral LightGCN embeddings (Ong et al., 2024). Tri-GFN uses AE, GCN, and Graph Transformer branches with layer-wise AE injection and final triple-channel enhancement $A_{TC}$1, then drives all branches with reconstruction and clustering objectives (Li et al., 18 Jul 2025).

A third pattern is graph fusion as an internal reranking or pruning device. KG-FiD inserts a passage graph module on the retriever side and again at an intermediate FiD encoder layer, then keeps only top reranked passages for upper encoder layers and the decoder (Yu et al., 2021). GRAF similarly uses attention-derived graph fusion before a downstream GCN, with edge elimination to reduce density (Kesimoglu et al., 2023). This suggests that graph fusion often functions less as the final predictor than as a selection, denoising, or structural regularization stage inside a broader system.

5. Objectives, regularization, and efficiency controls

The training objective of a graph fusion module is usually inherited from the end task, but the cited work adds module-specific losses or regularizers when fusion creates new failure modes. MERC-GCN uses multi-task cross-entropy over coarse-grained and fine-grained labels, with DropMessage on both node and edge features in the graph encoder (Feng et al., 25 Jan 2025). STFGNN uses Huber loss for forecasting, while relying on sparsity of $A_{TC}$2, residual connections, max pooling, and binary adjacencies for stability (Li et al., 2020). ARPGNet trains the fusion graph end-to-end with cross-entropy or focal loss, depending on dataset imbalance (Li et al., 27 Nov 2025). SMORE optimizes BPR plus an InfoNCE-style contrastive loss between behavioral and modality-side views, while spectral filters and behavior-guided gates suppress modality-specific noise before graph learning (Ong et al., 2024).

Several modules introduce explicit objectives to regularize projection or clustering. Project-and-Fuse adds a KL loss on the projection matrix to mitigate Biased-Assignment and an MSE loss on node centers to mitigate Ambiguous-Locality (Jiang et al., 31 Jan 2025). CaEGCN and Tri-GFN both use KL-based clustering losses and consistency objectives to align fused and branch-specific cluster distributions (Huo et al., 2021, Li et al., 18 Jul 2025). TFFM couples Tversky loss with soft clDice to make graph-enhanced vessel features topologically coherent rather than only pixel-accurate (Ahmed et al., 27 Jan 2026). GraphTransfer uses stage-wise optimization: auxiliary graph features are trained first, then the collaborative filtering backbone is optimized with cross-fusion losses $A_{TC}$3 and $A_{TC}$4 (Xia et al., 2024).

Efficiency constraints strongly shape graph fusion design. MERC-GCN limits graph size with a context window $A_{TC}$5 (Feng et al., 25 Jan 2025). STFGNN uses a short fusion window $A_{TC}$6, typically $A_{TC}$7, and explicitly notes that context windows and sparse storage are needed to control the $A_{TC}$8 fusion graph (Li et al., 2020). LCNet’s MHF partitions feature maps into $A_{TC}$9 windows with $v_i$0 and links each node to its top-5 in-group neighbors, avoiding dense hyperedges (Ma et al., 17 Jun 2026). KG-FiD moves graph reranking to an intermediate encoder layer and reports comparable performance with only 40% of the computation cost of vanilla FiD (Yu et al., 2021). GraFS addresses efficiency at the systems level by reducing graph analytics to three fused primitives and generating backend-specific code from that reduced form (Houshmand et al., 2020).

6. Empirical behavior, limitations, and design tensions

The empirical record across the cited work is consistent on one point: graph fusion usually helps when it is paired with an appropriate structural bias. In MERC-GCN, removing both fusion and graph drops performance to $v_i$1, $v_i$2, while fusion only gives $v_i$3, graph only gives $v_i$4, and using both gives $v_i$5, $v_i$6, indicating complementarity between cross-modal cleaning and dialogue-graph reasoning (Feng et al., 25 Jan 2025). In ARPGNet on AFEW, appearance only gives $v_i$7, relation only $v_i$8, concatenation $v_i$9, fusion graph without TRS $g_i$0, and the proposed TRS-constrained fusion graph $g_i$1, showing that local temporal graph structure matters beyond simple stream combination (Li et al., 27 Nov 2025). AGCM improves SOD metrics when inserted on high-level features and performs best when two AGCMs are used rather than none (Lee et al., 2023). GraphTransfer improves several CF backbones by aligning interaction scores across feature spaces rather than concatenating them (Xia et al., 2024).

At the same time, the literature records several limitations. MERC-GCN models speaker dependencies implicitly through windowed dialogue edges and self-loops, but same-speaker and cross-speaker relation types are not explicitly separated (Feng et al., 25 Jan 2025). STFGNN’s fusion is structural and fixed once the three graphs are built; the paper explicitly notes that there is no separate trainable fusion coefficient in $g_i$2 (Li et al., 2020). AGCM is applied only to the two highest-level encoder features because of computational cost and memory consumption (Lee et al., 2023). KG-FiD assumes a one-to-one mapping between articles and KG entities and relies on dynamic, question-specific graphs instead of a global passage graph (Yu et al., 2021). TFFM assumes that feature similarity in latent grid space is a useful proxy for vessel connectivity, which the paper identifies as a domain-specific assumption (Ahmed et al., 27 Jan 2026). GRAF assumes multiple graphs over a common node set and uses a two-stage process rather than end-to-end joint optimization of fusion and downstream GCN (Kesimoglu et al., 2023).

Several design tensions recur. The first is global coverage versus local reliability. STFGNN argues that fully learning temporal dependencies over long sequences can be expensive and noisy, and uses short fusion windows (Li et al., 2020). ARPGNet shows that fully connected temporal fusion is weaker than TRS-constrained attention (Li et al., 27 Nov 2025). LCNet reports that removing foreground/background grouping harms hypergraph fusion under low-light noise (Ma et al., 17 Jun 2026). The second is expressiveness versus stability. Tri-GFN gains from combining GCN, AE, and Graph Transformer, but deeper variants still suffer from over-smoothing (Li et al., 18 Jul 2025). The third is direct fusion versus denoised fusion. SMORE explicitly argues that direct modality fusion amplifies cross-modality noise and instead moves fusion to the spectral domain before graph learning (Ong et al., 2024). A plausible implication is that successful graph fusion modules tend to separate three concerns—representation alignment, structural propagation, and task-specific pruning—rather than collapsing them into a single undifferentiated block.

Across these works, the graph fusion module emerges as a reusable architectural idea rather than a fixed layer definition. It can fuse graphs, modalities, views, or analytics; it can operate through adjacency construction, attention, convolution, hypergraph incidence, or score alignment; and its effectiveness depends on how well its graph structure encodes the domain’s actual dependencies. The cited literature therefore treats graph fusion as a principled mechanism for imposing structured interaction on heterogeneous information, not merely as a graph-flavored synonym for feature combination.