X-REFINE: XAI-based RElevance input-Filtering and archItecture fiNe-tuning for channel Estimation

The paper proposes X-REFINE, an XAI-based framework that leverages a decomposition-based, sign-stabilized LRP epsilon rule to jointly filter irrelevant input subcarriers and fine-tune neural network architecture, thereby achieving a superior trade-off between interpretability, computational complexity, and bit error rate performance for 6G channel estimation.

The Gist

Imagine you are trying to tune an old radio to find a clear station in a storm. The signal is full of static (noise), and the radio has a million knobs and dials (a complex computer model) trying to clean it up.

In the world of 6G wireless communication, engineers use Artificial Intelligence (AI) to act as that super-radio. It tries to guess what the original message was, even when the signal is messy. But there's a problem: these AI models are "black boxes." They give you an answer, but they don't tell you how they got there. If the answer is wrong, you have no idea if it's because the signal was too bad, or because the AI got confused by a specific knob it shouldn't have turned.

This paper introduces a new tool called X-REFINE. Think of it as a "smart filter and tuner" that makes the AI radio transparent, faster, and more reliable.

Here is how it works, broken down into simple concepts:

1. The Problem: The "Black Box" Radio

Current AI models are like a chef who cooks a perfect meal but refuses to tell you which ingredients they used.

• The Issue: In critical situations (like self-driving cars or emergency calls), we need to trust the AI. If the AI is too complex, it wastes energy (battery) and computing power.
• The Old Fix: Previous methods tried to "poke" the AI with noise to see which parts reacted. It was like shaking the radio to see which knobs rattled. It worked okay, but it didn't look inside the radio to see which wires were actually doing the work.

2. The Solution: X-REFINE (The "X-Ray" Tuner)

The authors propose X-REFINE, which uses a technique called Explainable AI (XAI). Instead of just shaking the radio, X-REFINE uses an "X-ray" to see exactly which parts of the signal and which parts of the AI's brain are actually important.

It does two things at once:

A. Input Filtering (Cleaning the Signal)

Imagine you are listening to a choir. Some singers are singing the right notes (the pilot signals), some are singing in harmony (useful data), and some are just making noise (harmful interference).

• What X-REFINE does: It listens to the choir and says, "Hey, we don't need those 50 singers in the back making noise. Let's just listen to the 4 lead singers and the 10 helpful backup singers."
• The Result: It throws away the "noise" subcarriers (the bad data) before the AI even tries to process them. This saves energy and stops the AI from getting confused.

B. Architecture Fine-Tuning (Pruning the Brain)

Now imagine the AI model is a massive library with millions of books. Most of those books are empty or contain nonsense.

• What X-REFINE does: It reads the library and realizes, "We only need the top 3 shelves to find the answer. We can lock up the other 7 shelves and throw away the empty books."
• The Result: It "prunes" (cuts down) the internal structure of the AI. It keeps the most important "neurons" (the brain cells) and removes the ones that aren't helping.

3. How It Works: The "Backward Trace"

How does X-REFINE know what to keep and what to throw away?

• The Old Way (Perturbation): Like poking a bear with a stick to see if it growls. It's messy and indirect.
• The X-REFINE Way (Decomposition): It's like tracing a river back to its source. The AI says, "I made this prediction," and X-REFINE works backward through the math to say, "Ah, this specific piece of data and this specific brain cell contributed 90% to that answer. This other piece contributed nothing."
• The Magic: It uses a special math rule (called LRP-ϵ) that ensures it doesn't get confused by "negative" numbers (which can happen in radio signals). It stabilizes the view so the AI can clearly see what matters.

4. The Results: Faster, Smarter, Leaner

The authors tested this on different scenarios (like driving in the city vs. on a highway).

• Performance: The AI still guessed the signal perfectly (low error rate), just as well as the giant, bloated version.
• Speed & Battery: Because it threw away the useless data and the useless brain cells, the computer had to do 35% to 62% less work.
• Trust: Because we can see why the AI made a decision (it only looked at the good singers and used the top 3 shelves), we trust it more.

The Bottom Line

X-REFINE is like taking a bloated, confusing AI model and giving it a haircut and a diet.

1. It filters out the noise so the AI only listens to what matters.
2. It prunes the brain so the AI doesn't waste energy thinking about things that don't matter.
3. It explains its work so engineers know it's safe to use in critical 6G systems.

The result is a 6G system that is faster, uses less battery, and is transparent enough for us to trust with our lives.

Technical Summary

1. Problem Statement

The transition to 6G wireless systems relies heavily on AI-native architectures, particularly Deep Learning (DL) models like Feed-forward Neural Networks (FNNs), for tasks such as channel estimation. However, these models face three critical barriers to practical deployment:

• Black-box Nature: They lack transparency, making it difficult to guarantee reliability and safety in critical applications (e.g., V2X communications).
• High Complexity: Full DL models are computationally expensive, which conflicts with the ultra-reliable low-latency communication (URLLC) requirements of 6G.
• Limitations of Existing XAI: Previous Explainable AI (XAI) approaches, such as the authors' earlier work XAI-CHEST, rely on perturbation-based methods. These methods filter inputs but fail to optimize the internal model architecture, missing opportunities for structural pruning and further complexity reduction.

2. Methodology: The X-REFINE Framework

The authors propose X-REFINE, a framework that performs joint optimization of model inputs and architecture using a decomposition-based XAI approach.

A. Core Mechanism: Sign-Stabilized LRP-$\epsilon$

Unlike perturbation-based methods, X-REFINE utilizes Layer-wise Relevance Propagation (LRP) with a sign-stabilized $\epsilon$-rule.

• Decomposition: It backpropagates the prediction error through the network layers to assign relevance scores ($R$) to every input subcarrier and every hidden neuron.
• Stabilization: To handle complex-valued regression (common in channel estimation), the relevance is initialized based on the magnitude ($|\hat{h}|$) rather than the raw value. This prevents phase-induced cancellations and ensures that negative relevance scores reflect learned weights rather than output sign distortions.
• Formula: The relevance for neuron $i$ in layer $l$ is computed as:
  $$R^{(l)}_i = \sum_j \frac{z_{ij}}{\sum_k z_{kj} + \epsilon \cdot \text{sign}(\sum_k z_{kj})} R^{(l+1)}_j$$
  where $z_{ij}$ represents the connection strength, and $\epsilon$ is a stabilizer.

B. Double Optimization Problem

X-REFINE formulates a joint optimization problem to find the optimal input mask ($m^*_{in}$) and architectural mask ($m^*_{arch}$) that minimize Mean Squared Error (MSE) while reducing complexity.

1. Input Filtering: Subcarriers are filtered based on a relevance threshold ($\tau$). Only "Contributing" ($R>0$) and "Reliable" ($R \approx 1$) subcarriers are retained. "Harmful" ($R<0$) and "Neutral" ($R=0$) subcarriers are discarded.
2. Architecture Pruning: Hidden neurons are pruned based on a percentile-based threshold ($P$). This ensures structural sparsity (e.g., removing the bottom 15–30% of neurons) without collapsing the network, preserving the most significant features relative to each layer's distribution.
3. Search Strategy: Due to the non-convex nature of the joint search space, the authors employ a structured numerical grid search over thresholds ($\tau$) and percentiles ($P$) to empirically guarantee Bit Error Rate (BER) performance while minimizing complexity.

C. Complexity Reduction

The framework quantifies complexity reduction using Floating-Point Operations (FLOPs). By reducing the number of active inputs ($\|m_{in}\|_0$) and active neurons ($\|m_{arch}\|_0$), the total FLOPs are significantly lowered according to the formula:
$$C(m_{in}, m_{arch}) = \sum_{l=0}^{L-1} (2 \cdot \|m_l\|_0 \cdot \|m_{l+1}\|_0 + \|m_{l+1}\|_0)$$

3. Key Contributions

1. Novel Decomposition-Based XAI Scheme: Introduction of X-REFINE, which leverages sign-stabilized LRP-$\epsilon$ to identify relevant components (inputs and architecture) simultaneously, offering higher resolution and faithfulness than perturbation-based methods.
2. Joint Optimization Framework: Derivation of analytical expressions and simulation protocols for simultaneously optimizing input feature sets and internal network topology.
3. Performance-Complexity Trade-off: Demonstration that using only relevant inputs and neurons maintains robust BER performance while drastically reducing computational load, outperforming full-model baselines and previous XAI methods.

4. Simulation Results

The framework was evaluated using an OFDM system with an FNN-based denoising unit under IEEE 802.11p standards, testing both Low-Frequency (LF) and High-Frequency (HF) selective channels with QPSK and 64QAM modulations.

• Relevance Distribution: X-REFINE correctly identified pilot subcarriers as "Reliable." It showed a more sparse and trustworthy relevance assignment compared to XAI-CHEST.
  • Observation: In higher-order modulations (64QAM), the model naturally neglected more distorted inputs (increased "Neutral" subcarriers) compared to QPSK.
• BER Performance:
  • X-REFINE achieved equal or better BER than the full FNN model and the XAI-CHEST framework.
  • In LF scenarios, retaining only pilot subcarriers yielded the best BER.
  • Optimal pruning percentiles varied by scenario (e.g., 15% pruning for 64QAM HF, 25% for QPSK LF), balancing capacity and sparsity.
• Computational Complexity:
  • X-REFINE achieved a 35.16% to 43.59% reduction in FLOPs across scenarios.
  • This significantly outperformed XAI-CHEST, which achieved only 24.70% to 32.93% reduction.
  • The joint pruning of inputs and architecture was the primary driver of this efficiency.

5. Significance

The paper presents a critical step toward deployable AI in 6G. By moving beyond simple input filtering to holistic model refinement, X-REFINE addresses the "black box" problem while simultaneously solving the resource constraint issue.

• Trust: It provides interpretability by explicitly showing which inputs and neurons drive decisions.
• Efficiency: It enables the deployment of high-performance deep learning models on resource-constrained edge devices by reducing computational overhead by nearly 40% without sacrificing accuracy.
• Scalability: The framework is designed to be adaptable to other XAI schemes and network architectures (e.g., RNNs) in future work.