⚡ electrical engineering

Algorithm Unrolling-based Denoising of Multimodal Graph Signals

This paper proposes a deep algorithm unrolling-based denoising method for multimodal graph signals that simultaneously learns twofold graph structures and restores signals using an alternating minimization scheme with primal-dual splitting.

Original authors: Hayate Kojima, Keigo Takanami, Junya Hara, Yukihiro Bandoh, Seishi Takamura, Hiroshi Higashi, Yuichi Tanaka

Published 2026-04-23

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Hayate Kojima, Keigo Takanami, Junya Hara, Yukihiro Bandoh, Seishi Takamura, Hiroshi Higashi, Yuichi Tanaka

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Big Picture: Cleaning Up a Messy Symphony

Imagine you are trying to listen to a beautiful symphony, but the recording is full of static, pops, and hisses. This is what happens in sensor networks (like weather stations or IoT devices). They collect data, but that data is often "noisy" or corrupted.

Usually, we think of this data as a simple list of numbers. But in the real world, data is multimodal. It's not just one number; it's a whole package. For example, a single weather station doesn't just measure temperature; it measures temperature, humidity, wind speed, and pressure all at once.

This paper proposes a new way to clean up this messy data. Instead of just scrubbing the noise off, the authors teach the computer to rebuild the map of how the data points relate to each other while it cleans them.

The Problem: The "Blind" Cleaner

Traditional methods for cleaning data usually work like this:

The Map is Fixed: You give the computer a pre-made map showing how the sensors are connected (e.g., "Sensor A is next to Sensor B").
The Cleaning: The computer smooths out the noise based on that map.

The Flaw: In the real world, we often don't have the map. We don't know exactly how the sensors relate to each other, or how the different types of data (temperature vs. humidity) influence one another. If you try to clean the data using a wrong or missing map, the result is still messy.

The Solution: The "Unrolling" Detective

The authors propose a method called Algorithm Unrolling. Think of this as a detective who doesn't just look at the clues; they learn how to solve the case by practicing on past cases.

Here is how their method works, broken down into simple steps:

1. The Two-Layer Cake (The Twofold Graph)

Imagine your data is a giant cake with two layers of relationships:

Layer 1 (Spatial): How the sensors relate to each other in space (e.g., Station A is close to Station B).
Layer 2 (Modality): How the different measurements relate to each other (e.g., Temperature usually goes up when Humidity goes down).

The goal is to clean the cake while simultaneously figuring out the recipe for both layers.

2. The Alternating Dance

The algorithm performs a "dance" with two steps, repeating them over and over:

Step A: Learn the Map. Look at the current data and guess: "If the data is smooth, how should these sensors be connected?"
Step B: Clean the Data. Use that new map to smooth out the noise.
Repeat: Now that the data is a little cleaner, the map looks better. Now that the map is better, the data can be cleaned even more.

3. The "Unrolling" Trick (Deep Learning)

This is the clever part. Usually, this "dance" takes a long time to settle down, and you have to manually tune the speed and rhythm (hyperparameters).

The authors use Deep Algorithm Unrolling. Imagine taking that dance routine and turning it into a video game level with 9 distinct stages (layers).

Instead of manually setting the rules for every stage, they feed the computer thousands of "clean" examples.
The computer learns the perfect rhythm and speed for each specific stage of the dance.
It learns that "Stage 1 needs to be slow and gentle," while "Stage 9 needs to be fast and precise."

This allows the system to learn the best way to clean the data without needing a human to tweak the knobs.

The Results: Why It's Better

The paper tested this on two things:

Fake Data: They created a perfect digital world and added noise. Their method cleaned it up better than any existing method, even beating methods that knew the perfect map in advance.
Real Data: They used 10 years of Japanese weather data.
- The Result: Their method successfully removed the noise while keeping the important patterns (like seasonal changes) intact.
- The "Aha!" Moment: When they looked at the maps the computer learned, they realized the computer had figured out real-world geography! It connected weather stations that are geographically close (like Hokkaido and Tohoku) and connected dates that have similar weather patterns (like January and December).

The Takeaway

Think of this method as a smart restorer of an old, damaged painting.

Old methods try to fix the paint using a rigid, pre-drawn sketch of the image. If the sketch is wrong, the painting looks weird.
This new method is like a master artist who looks at the damaged painting, guesses what the original sketch should have been, fixes the paint, updates the sketch, and repeats until the image is perfect. And the best part? The artist learned how to do this by studying thousands of other paintings, so they don't need a human supervisor to tell them how hard to press the brush.

In short: They built a system that cleans noisy sensor data by learning the hidden connections between the data points and the types of measurements, all while teaching itself the perfect way to do the job.

1. Problem Statement

The paper addresses the challenge of denoising multimodal graph signals where the underlying graph structures are unknown and must be learned simultaneously.

Context: In sensor networks (e.g., IoT, environmental monitoring), data often consists of multiple modalities (e.g., temperature, humidity) measured at various spatial locations.
The "Twofold Graph" Concept: These data points can be modeled as signals on a twofold graph:
1. A Spatial Graph ( $G_s$ ): Representing correlations between physical sensor locations.
2. A Modality Graph ( $G_m$ ): Representing correlations between different sensor features (modalities).
The Challenge: Existing methods typically assume the graph structure is known a priori or focus only on single-modal signals. In real-world scenarios, graphs are rarely given, and noise corrupts the observations, making graph estimation difficult. The goal is to recover the clean signal matrix $X$ from noisy observations $Y = X + N$ while simultaneously estimating the Laplacian matrices for both $G_s$ and $G_m$ .

2. Methodology

The proposed method, MGSD-LLAP-DAU, combines optimization theory with Deep Algorithm Unrolling (DAU).

A. Problem Formulation

The authors formulate the problem as a joint optimization of signal restoration and graph learning:
$\min_{X, L_s, L_m} \|Y - X\|_F^2 + f_s(X, L_s) + f_m(X^\top, L_m)$

Data Fidelity: $\|Y - X\|_F^2$ ensures the output is close to observations.
Regularization ( $f_e$ ): Based on signal smoothness assumptions. The regularization term includes:
1. Smoothness: $\text{tr}(X^\top L X)$ (encourages smooth signals on the graph).
2. Connectivity: $-\beta \mathbf{1}^\top \log(\text{diag}(L))$ (encourages graph connectivity).
3. Sparsity: $\gamma \|L\|_F^2$ (encourages sparse edge weights for computational efficiency).

B. Alternating Minimization

Since the joint problem is non-convex, the authors split it into an alternating iterative scheme with two main blocks per iteration:

Signal Update: Solves for $X$ given fixed graphs. This has a closed-form solution using Tikhonov regularization (essentially a graph low-pass filter).
Graph Learning: Solves for $L_s$ and $L_m$ given fixed signals. This is a convex subproblem solved using the Primal-Dual Splitting (PDS) algorithm.

C. Deep Algorithm Unrolling (DAU)

To overcome the limitations of manually tuning hyperparameters (regularization strengths $\alpha, \beta, \gamma$ ) and to accelerate convergence:

The iterative algorithm is "unrolled" into a deep neural network where each iteration corresponds to a layer.
Learnable Parameters: The hyperparameters $\{\alpha_e^{(t)}, \beta_e^{(t)}, \gamma_e^{(t)}\}$ for each layer $t$ are treated as trainable weights.
Training: The network is trained end-to-end using backpropagation to minimize the Mean Squared Error (MSE) between the predicted signal and the ground truth.
Benefit: This allows the model to learn optimal, layer-specific regularization strategies that adapt to the noise level and data distribution, rather than using fixed global parameters.

3. Key Contributions

Simultaneous Learning: The first method to perform simultaneous denoising and graph learning for multimodal signals on twofold graphs (spatial and modality).
DAU Integration: Successfully applies Deep Algorithm Unrolling to a complex, non-convex joint optimization problem involving graph learning, reducing the need for manual hyperparameter tuning.
Robustness to Noise: The method learns the graph structure during the denoising process, making it more robust to noise compared to methods that construct graphs directly from noisy data.
Interpretability: Unlike black-box Graph Neural Networks (GNNs), the proposed method retains the interpretability of the underlying optimization algorithm (alternating minimization).

4. Experimental Results

The method was evaluated on both synthetic and real-world datasets.

Datasets:
- Synthetic: Random sensor graphs with Gaussian Markov Random Field (GMRF) signals and piecewise constant modality signals.
- Real-world: Japanese climate data (temperature) from 62 locations over 10 years (Spatial: locations; Modality: days/seasons).
Comparisons: The proposed method was compared against:
- Model-based: Graph Low-Pass Filter (GLPF), Heat Diffusion (HD), Singular Value Decomposition with Hard Shrinkage (SVDS).
- Data-driven: Autoencoder (AE), Graph Convolutional Network (GCN).
- Hybrid/DAU: TGSR-DAU (a previous DAU method that assumes fixed graphs).
Performance:
- RMSE Reduction: The proposed method achieved the lowest Root Mean Square Error (RMSE) across all noise levels in both datasets.
  - Synthetic (σ=0.30): Proposed (0.076) vs. TGSR-DAU (0.155) vs. GCN (0.195).
  - Real-world (σ=9): Proposed (2.114) vs. TGSR-DAU (4.072) vs. GCN (4.082).
- Ablation Study: The full model (learning both graphs) outperformed even the "Oracle" baseline (which used the ground-truth graphs). This suggests that the learned graphs in the intermediate layers were better suited for the specific denoising task than the true underlying graphs.
- Qualitative Analysis: Visualizations showed that the proposed method effectively removed noise while preserving signal dynamics, whereas other methods either oversmoothed the data or failed to remove noise effectively.

5. Significance

This paper represents a significant advancement in Graph Signal Processing (GSP) by bridging the gap between traditional model-based optimization and modern deep learning.

Practical Impact: It solves a critical bottleneck in sensor network applications where graph structures are unknown and data is noisy.
Methodological Innovation: It demonstrates that unrolling complex iterative algorithms (like PDS) allows for the automatic learning of hyperparameters, leading to superior performance without sacrificing the physical interpretability of the signal processing model.
Future Direction: The success of learning "twofold" graphs opens new avenues for processing complex, multi-dimensional data structures in IoT, medical imaging, and social network analysis.