Dynamic Uncertainty Graph Convolution (DUGC)

• Dynamic Uncertainty Graph Convolution (DUGC) is a family of graph modules that use uncertainty signals for adaptive, data-driven graph formation and message propagation.
• It is applied in various domains such as aerial object detection, salient object detection, trust evaluation, and XL-MIMO channel estimation to selectively refine outputs based on uncertainty levels.
• Empirical results demonstrate that uncertainty-aware propagation improves robustness and accuracy by dynamically weighting uncertain states while mitigating noise and overfitting.

Dynamic Uncertainty Graph Convolution Module (DUGC) denotes a class of graph-convolution mechanisms in which graph construction, message passing, or downstream feature modulation is explicitly driven by uncertainty signals that are recomputed from the current data instance, layer state, or iteration state. In the supplied literature, the term appears directly in salient object detection and in the name of DUGC-VRNet, while closely related functionality is implemented under different nomenclature in uncertainty-aware object detection and dynamic trust evaluation. Across these formulations, the common pattern is dynamic graph formation from spatial, semantic, temporal, or structural relations; uncertainty-sensitive propagation on that graph; and selective refinement or weighting of predictions, features, or optimization updates (Xiong et al., 28 Aug 2025, Kim et al., 2022, Usman et al., 8 Oct 2025, Nie et al., 24 Mar 2026).

1. Terminological scope and conceptual definition

The name DUGC is not used uniformly across the cited works. In "Object Detection in Aerial Images with Uncertainty-Aware Graph Network" (Kim et al., 2022), the paper introduces Uncertainty-Aware Graph network for object DETection (UAGDet), and the supplied technical note states that UAGDet “implements dynamic, uncertainty-driven graph convolution that aligns with the DUGC concept.” By contrast, "Graph-Based Uncertainty Modeling and Multimodal Fusion for Salient Object Detection" explicitly defines “a dynamic uncertainty graph convolution module (DUGC)” as a component of DUP-MCRNet (Xiong et al., 28 Aug 2025). In "DGTEN: A Robust Deep Gaussian based Graph Neural Network for Dynamic Trust Evaluation with Uncertainty-Quantification Support," DUGC is presented as a modular mapping from DGTEN’s uncertainty-aware dynamic trust convolution (Usman et al., 8 Oct 2025). In "DUGC-VRNet: Joint VR Recognition and Channel Estimation for Spatially Non-Stationary XL-MIMO," DUGC appears in the model name and refers to the graph-convolution component that infers soft visibility regions and feeds them back into a deep unfolding network (Nie et al., 24 Mar 2026).

A frequent misconception is that DUGC denotes a single canonical layer with fixed equations. The literature in the supplied corpus does not support that interpretation. Instead, DUGC refers to a recurrent design principle: uncertainty is treated as a first-class control signal for graph operations. Depending on the domain, uncertainty may be represented as MC-Dropout variance over object predictions, a learned pixel-wise uncertainty map, Gaussian standard deviations attached to nodes and edges, or a soft visibility mask over antennas. This suggests that DUGC is best understood as a family of uncertainty-conditioned graph modules rather than a single standardized operator.

Formulation	Graph domain	Uncertainty signal
UAGDet	detected objects	MC Dropout-derived $\phi_i$
DUP-MCRNet DUGC	feature-map pixels	learned map $U^{(\ell)}$
DGTEN mapping	trust graph nodes and edges	Gaussian $\boldsymbol{\sigma}$
DUGC-VRNet	user–antenna graph	soft VR mask $\mathbf{u}^{(t)}$

2. Object-centric dynamic uncertainty graph convolution in aerial detection

In UAGDet, the operational pattern associated with DUGC begins with a two-stage detector, specifically Faster R-CNN with RoITransformer for oriented boxes, which generates proposals $\mathrm{prop}_i$, RoI features, classification outputs, and box regression outputs. Uncertainty is then estimated by lightweight MC Dropout applied only on the last FC layers of the classification and regression heads for $M$ stochastic forward passes, yielding aggregated predictions and per-object uncertainty $\phi_i$. The supplied formulation gives $p_i = \mathrm{mean}_j\, p_i^{(j)}$, $$\mathrm{bbox}_i = \mathrm{mean}_j\, \mathrm{bbox}_i^{(j)}$$, and $\phi_i = \mathrm{stdev}_j\, p_i^{(j)}$. After NMS, nodes are sorted by uncertainty and split dynamically into certain source nodes and uncertain target nodes, with the source set defined as the half with the lowest $U^{(\ell)}$0 and the target set as the half with the highest $U^{(\ell)}$1 (Kim et al., 2022).

The graph is a directed bipartite graph $U^{(\ell)}$2 with $U^{(\ell)}$3, and edges only from certain to uncertain nodes. Edge existence is gated by both spatial and semantic proximity. The spatial distance is

$U^{(\ell)}$4

and the semantic distance is

$U^{(\ell)}$5

An edge is added if the corresponding threshold condition is satisfied. Aggregation weights are based on spatial distance only,

$U^{(\ell)}$6

This design prevents noisy back-propagation from uncertain targets to certain sources because certain nodes have no incoming edges.

Node features combine a visual down-projection and a class embedding. The technical note specifies

$U^{(\ell)}$7

$U^{(\ell)}$8

and

$U^{(\ell)}$9

Two GCN layers with LeakyReLU propagate messages only to uncertain nodes. A standard update written in the supplied note is

$\boldsymbol{\sigma}$0

with $\boldsymbol{\sigma}$1. The graph output $\boldsymbol{\sigma}$2 is concatenated with the original RoI feature to produce refined classification logits.

Selective refinement is integral to the module. Only uncertain nodes are refined by graph propagation, and during evaluation refined predictions replace only uncertain objects, while certain objects keep their initial predictions. The training objective also upweights uncertain nodes through

$\boldsymbol{\sigma}$3

and

$\boldsymbol{\sigma}$4

with

$\boldsymbol{\sigma}$5

On DOTA-v1.0, the RoITrans baseline is reported as 73.4 mAP and UAGDet as 75.1; on DOTA-v1.5, the RoITrans baseline is 65.5 and UAGDet is 68.0. The supplied ablations further report that all-pair propagation gives 73.1, whereas directed certain$\boldsymbol{\sigma}$6uncertain propagation gives 75.1, supporting the claim that allowing uncertain nodes to influence certain nodes harms performance (Kim et al., 2022).

3. Pixel-wise DUGC in salient object detection

In DUP-MCRNet, DUGC is defined at the level of feature-map positions rather than detected instances. For a low-level feature map $\boldsymbol{\sigma}$7, a $\boldsymbol{\sigma}$8 convolution maps it to $\boldsymbol{\sigma}$9, which is flattened into a node sequence $\mathbf{u}^{(t)}$0 with $\mathbf{u}^{(t)}$1. Each spatial position is a node with feature $\mathbf{u}^{(t)}$2 and coordinate $\mathbf{u}^{(t)}$3. The graph is built from a combined spatial-semantic distance

$\mathbf{u}^{(t)}$4

where

$\mathbf{u}^{(t)}$5

and

$\mathbf{u}^{(t)}$6

For each node, the $\mathbf{u}^{(t)}$7 nearest neighbors under $\mathbf{u}^{(t)}$8 define a sparse binary adjacency, self-loops are added, and the normalized operator is

$\mathbf{u}^{(t)}$9

DUGC then applies three residual graph convolution layers,

$\mathrm{prop}_i$0

The module is termed dynamic because the graph topology depends on image content and layer $\mathrm{prop}_i$1, is recomputed per batch, and yields a data-dependent uncertainty map (Xiong et al., 28 Aug 2025).

Uncertainty is not defined by entropy, MC sampling, or an aleatoric/epistemic split. Instead, it is learned from graph-propagated features:

$\mathrm{prop}_i$2

This uncertainty map multiplicatively modulates the projected low-level feature:

$\mathrm{prop}_i$3

The paper states that high-uncertainty regions can be selectively enhanced or suppressed through the learnable MLP output. In this formulation, uncertainty affects downstream fusion rather than directly entering the graph kernel as an edge-wise gate.

DUGC also includes channel-adaptive interaction with higher-level features. For adjacent levels $\mathrm{prop}_i$4 with $\mathrm{prop}_i$5, higher-level features are projected to $\mathrm{prop}_i$6 channels, bilinearly upsampled, concatenated with $\mathrm{prop}_i$7, and processed with two $\mathrm{prop}_i$8 convolutions and ReLU. For $\mathrm{prop}_i$9, the paper uses asymmetric cross-attention with $M$0 as Query and $M$1 as Key/Value:

$M$2

Aggregated interaction outputs pass through a bottleneck

$M$3

Within DUP-MCRNet, DUGC is applied per modality stream for RGB, Depth, and Edge, after which Multimodal Collaborative Fusion combines the attention outputs with learnable gating weights $M$4.

The supervision tied to this design is multi-scale BCE and IoU loss plus cross-scale consistency, rather than an explicit uncertainty-weighted objective. The total loss is

$M$5

Ablation numbers reported for ECSSD, HKU-IS, and SOD show that DUGC alone improves over the base model on several metrics, and DUGC+MCF yields the best overall configuration. For SOD, the reported values are: base MAE 0.094, $M$6 0.665, $M$7 0.795, $M$8 0.758; DUGC only MAE 0.090, $M$9 0.677, $\phi_i$0 0.801, $\phi_i$1 0.765; DUGC+MCF MAE 0.078, $\phi_i$2 0.711, $\phi_i$3 0.827, $\phi_i$4 0.796 (Xiong et al., 28 Aug 2025).

4. Gaussian uncertainty propagation in dynamic trust graphs

In DGTEN, the DUGC mapping is structurally different from the vision-oriented modules because uncertainty is embedded directly in Gaussian node and edge representations. Each node is initialized as

$\phi_i$5

with diagonal-covariance semantics enforced through independent standard deviations. The initialization uses feature projection, a sinusoidal Gaussian mapping, and Gaussian parameterization,

$\phi_i$6

Edges are similarly mapped to Gaussian embeddings at each layer from raw edge labels by a per-layer sinusoidal transform and Gaussian parameterization. The supplied note states that uncertainty reflects epistemic uncertainty over interaction semantics, but the paper does not separate aleatoric and epistemic components (Usman et al., 8 Oct 2025).

Message passing is controlled by Robust Adaptive Ensemble Coefficient Analysis (RAECA). Cosine and Jaccard similarities are computed from node means, pruned by thresholds, fused by a quadratic-mean-style rule, degree-normalized, and combined with self-loops to produce coefficients $\phi_i$7. These coefficients modulate both mean and standard-deviation aggregation from incoming and outgoing neighborhoods and from edge-opinion embeddings. The trustee-side mean and standard-deviation aggregation, for example, is

$\phi_i$8

After concatenating incoming, outgoing, opinion-in, and opinion-out channels, the update is

$\phi_i$9

followed by

$p_i = \mathrm{mean}_j\, p_i^{(j)}$0

This is uncertainty-aware convolution in a literal sense: the propagated state contains both semantic content and uncertainty magnitude.

DGTEN then adds temporal modeling through HAGH positional encoding, KAN-based multi-head causal attention, and an ODE residual module. Structural embeddings across snapshots form $p_i = \mathrm{mean}_j\, p_i^{(j)}$1, temporal interaction yields $p_i = \mathrm{mean}_j\, p_i^{(j)}$2, residuals are defined as $p_i = \mathrm{mean}_j\, p_i^{(j)}$3, and a neural ODE integrates those residuals over $p_i = \mathrm{mean}_j\, p_i^{(j)}$4 to obtain $p_i = \mathrm{mean}_j\, p_i^{(j)}$5, with final embeddings

$p_i = \mathrm{mean}_j\, p_i^{(j)}$6

The paper does not define an ODE for $p_i = \mathrm{mean}_j\, p_i^{(j)}$7, so temporal refinement operates primarily on semantic embeddings while $p_i = \mathrm{mean}_j\, p_i^{(j)}$8 is retained for uncertainty analysis and defenses.

Empirically, the supplied results report that on Bitcoin-Alpha single-timeslot prediction DGTEN improves MCC by 10.77% over the best dynamic baseline, with 0.401±0.008 versus 0.362±0.004; on the cold-start task it achieves a 16.41% MCC gain, 0.447±0.018 versus 0.384±0.026; and under on–off attacks it surpasses the baseline by up to 11.63% MCC. An ablation on Bitcoin-OTC Task-1 reports Full DGTEN at MCC 0.414±0.005, while “only Deep Gaussian” yields 0.386±0.074 (Usman et al., 8 Oct 2025).

5. DUGC as uncertainty-guided graph coupling in XL-MIMO

In DUGC-VRNet, the uncertainty-bearing object is neither an object node nor a pixel uncertainty map, but a soft visibility-region mask over antennas in a near-field XL-MIMO system. The measurement model is

$p_i = \mathrm{mean}_j\, p_i^{(j)}$9

and, after stacking,

$$\mathrm{bbox}_i = \mathrm{mean}_j\, \mathrm{bbox}_i^{(j)}$$0

The channel is modeled as

$$\mathrm{bbox}_i = \mathrm{mean}_j\, \mathrm{bbox}_i^{(j)}$$1

where the binary or relaxed mask $$\mathrm{bbox}_i = \mathrm{mean}_j\, \mathrm{bbox}_i^{(j)}$$2 encodes visibility regions. The paper’s stated motivation is that conventional channel estimation algorithms typically struggle to identify and adapt to the partial antenna visibility caused by varying VRs, and that incorrect visibility assumptions either overfit noise or miss signal-support antennas (Nie et al., 24 Mar 2026).

The backbone is a deep unfolding network (DUN) coupled with a GCN. At iteration $$\mathrm{bbox}_i = \mathrm{mean}_j\, \mathrm{bbox}_i^{(j)}$$3, the DUN outputs an intermediate estimate $$\mathrm{bbox}_i = \mathrm{mean}_j\, \mathrm{bbox}_i^{(j)}$$4. The GCN forms a graph over one user node and $$\mathrm{bbox}_i = \mathrm{mean}_j\, \mathrm{bbox}_i^{(j)}$$5 antenna nodes, refines the channel into $$\mathrm{bbox}_i = \mathrm{mean}_j\, \mathrm{bbox}_i^{(j)}$$6, and outputs a soft VR mask $$\mathrm{bbox}_i = \mathrm{mean}_j\, \mathrm{bbox}_i^{(j)}$$7. The DUN update is then made VR-aware:

$$\mathrm{bbox}_i = \mathrm{mean}_j\, \mathrm{bbox}_i^{(j)}$$8

where the diagonal weighting is

$$\mathrm{bbox}_i = \mathrm{mean}_j\, \mathrm{bbox}_i^{(j)}$$9

The corresponding prior synthesis imposes sparsity outside the predicted VR:

$\phi_i = \mathrm{stdev}_j\, p_i^{(j)}$0

The GCN operates on node features

$\phi_i = \mathrm{stdev}_j\, p_i^{(j)}$1

with $\phi_i = \mathrm{stdev}_j\, p_i^{(j)}$2 and normalized position $\phi_i = \mathrm{stdev}_j\, p_i^{(j)}$3. Edges from the user node to antenna nodes are present when $\phi_i = \mathrm{stdev}_j\, p_i^{(j)}$4, where the threshold $\phi_i = \mathrm{stdev}_j\, p_i^{(j)}$5 is learned by backpropagation. The normalized adjacency is

$\phi_i = \mathrm{stdev}_j\, p_i^{(j)}$6

and each GCN layer updates features as

$\phi_i = \mathrm{stdev}_j\, p_i^{(j)}$7

A Sigmoid head produces the soft VR mask

$\phi_i = \mathrm{stdev}_j\, p_i^{(j)}$8

and the user entry is discarded. Soft masks, learned thresholding, and a Sigmoid feature gate in the ResCNN prior are the module’s uncertainty-handling mechanisms.

Training uses a joint loss

$\phi_i = \mathrm{stdev}_j\, p_i^{(j)}$9

The reported setting includes $U^{(\ell)}$00, $U^{(\ell)}$01, $U^{(\ell)}$02, 16,000 training samples, 2,000 validation samples, 2,000 testing samples, and 100 epochs, with pruning beginning at epoch 50. On the parameter–performance trade-off at 32 pilots and 10 dB SNR, DUGC-VRNet is reported at 2.59M parameters, NMSE = -31.92 dB, SDR = 0.9968; the pruned $U^{(\ell)}$03 variant has 1.29M parameters, NMSE = -28.82 dB, SDR = 0.9944; MDISR-Net is reported at 2.41M parameters and NMSE = -27.28 dB (Nie et al., 24 Mar 2026).

6. Comparative design patterns, empirical effects, and limitations

Across the supplied works, several design patterns recur. First, graph topology is data-dependent rather than fixed. UAGDet recomputes certain and uncertain node sets per image and forward pass from $U^{(\ell)}$04 (Kim et al., 2022). DUP-MCRNet recomputes a sparse spatial-semantic k-NN graph per batch and layer (Xiong et al., 28 Aug 2025). DGTEN recomputes layerwise edge coefficients through RAECA, which includes pruning by similarity thresholds (Usman et al., 8 Oct 2025). DUGC-VRNet updates the user–antenna star graph through a learnable energy threshold $U^{(\ell)}$05 (Nie et al., 24 Mar 2026). This suggests that “dynamic” in DUGC consistently refers to input-conditioned graph structure or input-conditioned uncertainty control.

Second, the uncertainty variable plays different algebraic roles. In UAGDet, uncertainty selects which objects are sources or targets and rescales the refinement loss. In DUP-MCRNet, uncertainty is a learned pixel-wise gate $U^{(\ell)}$06. In DGTEN, uncertainty is part of the propagated latent state through $U^{(\ell)}$07. In DUGC-VRNet, uncertainty is a soft mask that modifies both the optimization objective and the prior network. A plausible implication is that DUGC should not be defined by a single uncertainty estimator, but by the structural fact that uncertainty actively alters graph propagation or downstream inference.

Third, the empirical effect reported across domains is improved robustness on ambiguous or difficult cases rather than uniform improvement from indiscriminate propagation. In aerial detection, directed certain$U^{(\ell)}$08uncertain propagation outperforms all-pair propagation, and removing complex node and edge features drops mAP from 75.1 to 73.9 (Kim et al., 2022). In salient object detection, DUGC only improves the SOD benchmark from MAE 0.094 to 0.090 and $U^{(\ell)}$09 from 0.758 to 0.765, while DUGC+MCF reaches 0.078 and 0.796, respectively (Xiong et al., 28 Aug 2025). In DGTEN, removing temporal or robust components lowers MCC, while omitting RAECA and using a mean aggregator yields a higher average MCC but an approximately 3460% variance increase, which the supplied note characterizes as unstable (Usman et al., 8 Oct 2025). In DUGC-VRNet, the full and pruned models both sustain high SDR, with SDR $U^{(\ell)}$10 even at 0 dB for DUGC-VRNet and nearly overlapping SDR curves for SNR $U^{(\ell)}$11 dB between the full and pruned variants (Nie et al., 24 Mar 2026).

The limitations are likewise domain-specific but structurally related. UAGDet depends on initial detection quality, manual thresholds $U^{(\ell)}$12 and $U^{(\ell)}$13, and an MC-Dropout uncertainty that may miss aleatoric box noise (Kim et al., 2022). DUP-MCRNet notes increased computational and memory overhead at high resolutions, sensitivity to $U^{(\ell)}$14 and $U^{(\ell)}$15, and incomplete validation for cross-domain generalization (Xiong et al., 28 Aug 2025). DGTEN notes that snapshot aggregation may hide intra-snapshot event order, RAECA assumes homophily, and $U^{(\ell)}$16 does not explicitly evolve under the ODE module (Usman et al., 8 Oct 2025). DUGC-VRNet is limited to a narrowband, single-user uplink with a ULA, and extension to wideband OFDM, UPA or 3D arrays, multi-user settings, and time-varying VRs is stated to require redesign (Nie et al., 24 Mar 2026).

7. Position within graph learning and uncertainty modeling

Relative to standard GCN or GAT formulations, the cited DUGC variants share the use of graph propagation but differ in how uncertainty is encoded and applied. DUP-MCRNet explicitly contrasts DUGC with a fully dense graph and with purely learned attention graphs, stating that it uses a data-driven sparse k-NN graph from a blended spatial-semantic metric and a learned uncertainty estimation MLP, rather than a purely learned attention graph as in GAT (Xiong et al., 28 Aug 2025). DGTEN contrasts its approach with deterministic GCN, GAT, and GraphSAGE by propagating Gaussian means and standard deviations and by adding HAGH, KAN-based attention, and RAECA for risk-aware trust decisions and adversarial robustness (Usman et al., 8 Oct 2025). UAGDet differs from generic context-graph methods by restricting message flow from certain nodes to uncertain nodes and by refining only uncertain detections (Kim et al., 2022). DUGC-VRNet differs from conventional model-driven channel estimators by feeding graph-inferred uncertainty back into the unfolding update as adaptive weights and gates (Nie et al., 24 Mar 2026).

The relation to prior uncertainty modeling is equally heterogeneous. DUP-MCRNet notes that many salient object detection methods derive uncertainty from prediction entropy or Bayesian approximations, whereas its uncertainty is learned from graph-propagated features through $U^{(\ell)}$17 (Xiong et al., 28 Aug 2025). UAGDet uses lightweight MC Dropout and uncertainty-scaled classification loss (Kim et al., 2022). DGTEN uses Gaussian standard deviations as the uncertainty carrier but does not add explicit calibration losses such as ECE or NLL (Usman et al., 8 Oct 2025). DUGC-VRNet encodes uncertainty through soft VR masks and soft gates instead of Bayesian posterior variance (Nie et al., 24 Mar 2026).

Taken together, these works place DUGC at the intersection of uncertainty quantification, sparse or structured graph reasoning, and task-specific adaptive refinement. The common scientific claim is not that graph convolution alone improves performance, but that graph convolution becomes materially more useful when uncertainty is used to decide where to connect, what to propagate, which states to trust, and which outputs to refine.