TL;DR
Researchers have developed optimized U-Net architectures that perform "blind" co-channel interference cancellation—removing unknown interfering signals from wireless transmissions—directly on resource-constrained edge devices. By employing depthwise separable convolutions and quantization, they reduced computational complexity by over 60% while maintaining, or in some cases even improving, signal recovery performance.
What Problem Does This Paper Address?
In our increasingly crowded wireless landscape, multiple devices often end up shouting over each other on the same frequency—a phenomenon known as Co-Channel Interference (CCI). Traditionally, cancelling this interference requires knowing exactly what the "noise" looks like. "Blind" CCI is the much harder task of cleaning a signal without any prior knowledge of the interfering source.
While Machine Learning (ML) has shown promise in solving this, most existing models are "heavyweights" designed for powerful servers. They demand massive memory and computational power, making them impractical for edge devices like IoT sensors, drones, or mobile phones that need to process signals in real-time with limited battery life. This paper tackles the "throughput gap": how to get high-performance interference cancellation onto low-power hardware.
Methods
The authors adapted the U-Net architecture—a model famous in medical imaging for its ability to "see" structures at different scales—for 1D signal processing. They proposed two variants:
- M1: A shallow model using an LSTM (Long Short-Term Memory) at its bottleneck to capture temporal dependencies.
- M2: A deeper, fully convolutional model designed for spatial feature extraction and better scalability.
To make these models "edge-ready," they applied three optimization "surgeries":
- Depthwise Separable Convolutions (Dw): Instead of standard convolutions, they decoupled spatial and channel-wise processing. This is the primary driver for reducing Multiply-Accumulate (MAC) operations.
- Quantization (Q): They used Quantization-Aware Training (QAT) to shrink the model from 32-bit floating-point numbers down to 8-bit integers (qint8), drastically reducing the memory footprint.
- Pruning: They tested unstructured pruning (removing the least important weights) to see how much "fat" could be trimmed before performance collapsed.
Datasets
The models were trained and evaluated using datasets from the ICASSP 2024 Grand Challenge on Radio Frequency Signal Separation. These include:
- EMISignal1: Man-made electromagnetic interference.
- CommSignal2 & 3: Digital wireless communication signals.
- CommSignal5G1: Standard 5G waveforms.
Crucially, the models were trained on all types simultaneously but tested on "unknown" interference to prove their "blind" capabilities.
Key Insights and Ideas
- The "Less is More" Paradox: For the fully convolutional model (M2), switching to depthwise separable convolutions actually improved the Mean Squared Error (MSE) by 0.63% while cutting compute by 61%. The authors suggest that the simpler Dw convolutions acted as a form of regularization, preventing the model from overfitting.
- LSTMs vs. Convolutions: While the LSTM-based M1 was excellent at small batch sizes, it struggled to scale on GPUs. The fully convolutional M2, however, showed massive throughput gains as batch sizes increased, reaching up to 800,000 symbols per second.
- The Limits of Pruning: Unlike many large-scale vision models, these optimized U-Nets were highly sensitive to pruning. Because the architectures were already meticulously tuned to be lightweight, even modest pruning (removing 10-25% of weights) led to significant performance drops.
- Quantization Trade-offs: Moving to 8-bit integers provided the smallest memory footprint (down to ~1.9 MB) but caused the most significant drop in signal quality compared to Dw convolutions.
Key Results
- Computational Efficiency: The M1(Dw) model reduced MAC operations by 58.66% with only a negligible 0.72% drop in MSE. M2(Dw) was even better, reducing MACs by 61.10% while slightly improving accuracy.
- Memory Footprint: Quantization shrunk the models significantly; M1(Q) requires only 1.90 MB of storage, making it feasible for even very modest microcontrollers.
- High Throughput: On an NVIDIA A40 GPU, the fully convolutional model achieved a symbol rate of 800k symbols/sec at large batch sizes, proving it can handle high-speed communication standards.
- Superiority over Baselines: Both M1 and M2 variants significantly outperformed established models like WaveNet and ConvTasNet in both signal recovery (MSE) and computational efficiency.
Limitations and Future Work
The authors acknowledge that while MSE (Mean Squared Error) is a good proxy for signal quality, the ultimate test for a communication system is the Bit Error Rate (BER)—how many 1s and 0s are actually misread. A full BER analysis remains for future study.
Additionally, the current pruning method (unstructured) creates sparse matrices that don't always translate to faster speeds on standard hardware. Future work will explore structured pruning (removing entire filters) and more advanced quantization techniques to further bridge the gap between theoretical efficiency and real-world hardware acceleration.
Summary updated