Source-linked AI summary
Radio frequency interference mitigation using deep convolutional neural networks
Joel Akeret, Chihway Chang, Aurelien Lucchi, Alexandre Refregier
TL;DR
Radio-frequency interference can contaminate radio-survey data and require software masking. This paper applies a U-Net convolutional neural network to classify contaminated pixels in telescope time-ordered data, training and evaluating it with HIDE & SEEK simulations and Bleien Observatory observations. The U-Net achieves strong simulated-data performance and competitive behavior with SEEK’s SumThreshold approach, while real-data performance is limited by interference patterns absent from training simulations.
Problem
Complex RFI patterns make automated masking difficult, while threshold-based methods require parameter tuning and can have environment-dependent false-positive rates.
Method
A U-Net classifies astronomical and RFI signatures in radio-telescope time-ordered data and returns per-pixel contamination probabilities.
Results
The U-Net achieves an excellent result on simulated data and produces masks on Bleien observations that resemble SEEK’s SumThreshold output.
Takeaways & Limitations
The publicly released U-Net implementation provides a deep-learning approach for flexible RFI masking in radio data.
Takeaways & Limitations
The U-Net trained on relatively simple HIDE simulations struggles with long-lasting broadband RFI in real data, including unsimulated satellite emissions.
Abstract
from arXiv · showhide
We propose a novel approach for mitigating radio frequency interference (RFI) signals in radio data using the latest advances in deep learning. We employ a special type of Convolutional Neural Network, the U-Net, that enables the classification of clean signal and RFI signatures in 2D time-ordered data acquired from a radio telescope. We train and assess the performance of this network using the HIDE & SEEK radio data simulation and processing packages, as well as early Science Verification data acquired with the 7m single-dish telescope at the Bleien Observatory. We find that our U-Net implementation is showing competitive accuracy to classical RFI mitigation algorithms such as SEEK's SumThreshold implementation. We publish our U-Net software package on GitHub under GPLv3 license.
1. Introduction
Radio surveys offer important cosmological and Galactic information but face complex RFI contamination that can make data unusable. Existing mitigation methods rely on morphological assumptions, thresholds, linear methods, or carefully selected features, motivating a U-Net approach to pixel-level RFI identification.
- RFI from satellites, phones, and aircraft communications varies across time and frequency and can make contaminated astronomical data unusable.
- Software masking remains necessary despite remote telescope locations and hardware measures such as ground shielding and band-pass filters.
- RFI masking seeks to minimize data loss while maintaining low contamination, commonly exploiting differences between smooth astronomical signals and localized or periodic interference.
- Existing methods include linear decomposition, thresholding algorithms such as SumThreshold, and supervised clustering requiring careful feature selection.SumThreshold is described as the most widely used algorithm in existing radio-data pipelines.
- Deep neural networks have recently achieved strong results in classification tasks, aided by customized hardware and open-source software.
- The paper applies a U-Net convolutional neural network to classify RFI in time-ordered radio data, presenting this as the first deep-learning application to this problem.
2. Proposed approach
The proposed U-Net combines a contracting CNN path with a symmetric expansive path to produce pixel-level contamination probabilities. It is trained using SumThreshold masks and evaluated through experiments varying architectural and training parameters.
- Network architecture: The U-Net extends a conventional CNN with a symmetric expansive path that upsamples extracted features into an output segmentation.
- Implementation: The implementation uses TensorFlow and Python, follows the original U-Net architecture, and is released on GitHub under a GPLv3 license.
- Network architecture: Figure 1 represents feature extraction through downsampling, propagation through upsampling, and concatenation between corresponding layers.
- Network architecture: A 1 × 1 convolution maps final features to binary pixel-contamination labels, followed by a pixel-wise soft-max probability map.
- Training: The network is trained on Bleien Observatory Science Verification data from a 7m single-dish telescope using SumThreshold masks as ground truth.
- Evaluation: The experiments vary network depth, first-layer feature count, and convolution-kernel size to assess classification performance and processing time.
- Training: Training uses cross-entropy optimization with momentum-based stochastic gradient descent, an initial learning rate of 0.2, 100 epochs, and mini-batches of 32.
3. Experimental results
The U-Net was evaluated on simulated and observed radio data, with performance examined across architectures and against SEEK’s SumThreshold masks. A three-layer, 64-feature network balanced prediction performance and computational cost while detecting narrow and broadband RFI signatures.
- Simulated data: The U-Net first identified RFI pixels in simulated radio data with perfect ground truth, enabling quantitative performance assessment.The simulations modeled instrument and atmospheric noise, elevation-dependent signal variations, and randomly sampled RFI bursts.
- Observed data: The CNN trained on simulations struggled with long-lasting broadband RFI signatures in observed data, including satellite emissions absent from the simulation model.
- Observed data: The observed-data evaluation used a SEEK SumThreshold mask containing both incorrectly masked pixels and undetected RFI pixels.
- Architecture comparison: Beyond a certain complexity, increasing U-Net layers or features did not significantly improve performance, and three layers with 64 features provided a good balance.
- Architecture comparison: The selected network can be trained in a few hours on a modern GPU and processes approximately 11.6 GB/h/GPU.
- Observed data: The U-Net captured narrow and broadband RFI signatures well, producing a mask that resembled SEEK’s SumThreshold output while learning local time-frequency characteristics.
4. Conclusion
The paper addresses the challenge of masking complex RFI in increasingly large radio surveys with a U-Net-based deep-learning approach. Evaluations using HIDE & SEEK simulations and Bleien Observatory data found competitive accuracy with SEEK’s SumThreshold, while the authors identify improved ground truth as a path for further development.
- Complex time- and frequency-dependent RFI makes general automated masking difficult, while thresholding methods require parameter tuning and can have environment-dependent false-positive rates.
- The U-Net learns features from radio telescope time-ordered data to distinguish astronomical signals from diverse RFI signatures and returns per-pixel RFI contamination probabilities.
- The network achieved excellent results on simulated data and competitive accuracy with SEEK’s SumThreshold on Bleien Observatory data.
- The method remains an initial step, with retraining on a small subset using improved ground truth identified as a possible improvement.
Appendix A. Distribution
The U-Net package is distributed through GitHub under the GPLv3 license and requires TensorFlow installation before setup.
- The package is released under the GPLv3 license, with development coordinated on GitHub and contributions welcomed.
- Users must clone the repository and install TensorFlow before running the setup procedure.
- The documented installation command is `python setup.py develop --user`.
Appendix B. Tensorflow U-Net usage example
The example constructs and trains a configurable TensorFlow U-Net, then applies the trained network to a supplied dataset for prediction.
- The package creates a U-Net with configurable layers, features, input channels, and output classes, then wraps it in a Trainer.The example uses 3 layers, 64 features, 1 channel, and 2 classes.
- Training uses a data provider, an output path, 32 training iterations, and 100 epochs.The data provider supplies data and labels, while the output path stores the network and intermediate learning statistics.
- Input data are image tensors shaped [number of images, nx, ny, channels], with one-hot labels shaped [number of images, nx, ny, number of classes].Here, nx and ny denote image dimensions in pixels.
- Prediction loads the trained network from a filesystem path and runs it on the dataset supplied for inference.The package documentation provides further parametrizations for both the U-Net and Trainer implementations.