Classifying Radio Signals from Space using Keras in Python

Hello everyone, welcome to Classifying Radio Signals from Space using Keras in Python. In this article, you will learn about how to classify radio signal using CNN, how to display results and plot 2D spectrograms with Python in Jupyter Notebook.

Here, we will be using the dataset which is provided by the SETI Institute. The dataset is already normalized and divided into two directories i.e. testing and validation dataset. You can download the dataset from here.

So Now let’s start working on the project.

Importing Libraries

First, we will import all the necessary Python libraries. Please make sure all the libraries given below are installed on your system and if not, install them using pip.

from livelossplot.tf_keras import PlotLossesCallback
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

import tensorflow as tf

from sklearn.metrics import confusion_matrix
from sklearn import metrics

import numpy as np
import warnings;warnings.simplefilter('ignore')
%matplotlib inline

Loading and Preprocessing The Data

Then we will load the dataset which is in CSV format using pandas.

train_images = pd.read_csv('dataset/train/images.csv', header=None)
train_labels = pd.read_csv('dataset/train/labels.csv', header=None)

val_images = pd.read_csv('dataset/validation/images.csv', header=None)
val_labels = pd.read_csv('dataset/validation/labels.csv', header=None)

Now, let’s see the dimensions of the training and validation dataset.

print("Training set shape:", train_images.shape, train_labels.shape)
print("Validation set shape:", val_images.shape, val_labels.shape)


Training set shape: (3200, 8192) (3200, 4)
Validation set shape: (800, 8192) (800, 4)

So now, we will reshape the data into the desired dimensions i.e. given below.

x_train = train_images.values.reshape(3200, 64, 128, 1)
x_val = val_images.values.reshape(800, 64, 128, 1)

y_train = train_labels.values
y_val = val_labels.values

Plotting 2D Spectrograms

So now, we will convert the NumPy array into 2d spectrograms. We will get random images from our training dataset for every execution. So in the output, you will see 3 images of 2d spectrogram which is a coloured image but we have to convert it into a grayscale image.

plt.figure(0, figsize=(12,12))
for i in range(1,4):
    img = np.squeeze(x_train[np.random.randint(0, x_train.shape[0])])


Signal Image
plt.imshow(np.squeeze(x_train[3]), cmap="gray");


Grayscale image 

Creating Training and Validation Data Generators

So now. we will perform real-time data augmentation using ImageDataGenerator. Here, we are flipping the images horizontally for the training and validation data.

from tensorflow.keras.preprocessing.image import ImageDataGenerator

datagen_train = ImageDataGenerator(horizontal_flip=True)

datagen_val = ImageDataGenerator(horizontal_flip=True)

Creating CNN Model

Before we start creating the model first we have to import all the layers, models, optimizers and callbacks. In this model, we will be using the following layers and optimizers as given below.

from tensorflow.keras.layers import Dense, Input, Dropout,Flatten, Conv2D
from tensorflow.keras.layers import BatchNormalization, Activation, MaxPooling2D

from tensorflow.keras.models import Model, Sequential
from tensorflow.keras.optimizers import Adam, SGD
from tensorflow.keras.callbacks import ModelCheckpoint, ReduceLROnPlateau
from tensorflow.keras.utils import plot_model

First, we initialize the model as Sequential model. Then, We will create the first convolution in which we will add Conv2D, BatchNormalization, Activation = ‘relu’, MaxPooling2D and the dropout layers. The input is taken in this layer with the shape as 64 * 128 and 1 representing that the image is of grayscale format. In the first convolution, we are passing 32 feature maps with 5,5 as the filter size.

Similarly, we will create another convolution with 64 feature maps this time. Next, We will add a flattening layer and after that a fully connected dense layer with 1024 neurons. Finally, In the output layer for the activation function, we are using ‘softmax’.

model = Sequential()

model.add(Conv2D(32,(5,5), padding='same', input_shape=(64, 128,1)))
model.add(MaxPooling2D(pool_size=(2, 2)))

model.add(Conv2D(64,(5,5), padding='same'))
model.add(MaxPooling2D(pool_size=(2, 2)))



model.add(Dense(4, activation='softmax'))

Now, let’s see the learning rate schedule. Initially, we will be setting the learning rate to 0.005 and using ExponentialDecay we will decay its value after 5 steps with decay rate as 0.96. We will use Adam optimizer here.

initial_learning_rate = 0.005
lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay(

optimizer = Adam(learning_rate=lr_schedule)

So, Let’s compile the model now and check its summary.

model.compile(optimizer=optimizer, loss='categorical_crossentropy', metrics=['accuracy'])


Model: "sequential"
Layer (type)                 Output Shape              Param #   
conv2d (Conv2D)              (None, 64, 128, 32)       832       
batch_normalization (BatchNo (None, 64, 128, 32)       128       
activation (Activation)      (None, 64, 128, 32)       0         
max_pooling2d (MaxPooling2D) (None, 32, 64, 32)        0         
dropout (Dropout)            (None, 32, 64, 32)        0         
conv2d_1 (Conv2D)            (None, 32, 64, 64)        51264     
batch_normalization_1 (Batch (None, 32, 64, 64)        256       
activation_1 (Activation)    (None, 32, 64, 64)        0         
max_pooling2d_1 (MaxPooling2 (None, 16, 32, 64)        0         
dropout_1 (Dropout)          (None, 16, 32, 64)        0         
flatten (Flatten)            (None, 32768)             0         
dense (Dense)                (None, 1024)              33555456  
batch_normalization_2 (Batch (None, 1024)              4096      
activation_2 (Activation)    (None, 1024)              0         
dropout_2 (Dropout)          (None, 1024)              0         
dense_1 (Dense)              (None, 4)                 4100      
Total params: 33,616,132
Trainable params: 33,613,892
Non-trainable params: 2,240

Model Training

Before we start training the model, first we will do the checkpointing and save the weights for which the validation loss is minimum and accuracy is best. Then, using PlotLossesCallback function we will graphically show the loss and the accuracy after each epoch.

So for training, we will set the batch size as 32 and the number of epochs as 12. We will shuffle the inputs because if there is an order we can eliminate its possibility.

checkpoint = ModelCheckpoint("model_weights.h5", monitor='val_loss',
                             save_weights_only=True, mode='min', verbose=0)
callbacks = [PlotLossesCallback(), checkpoint]#, reduce_lr]
batch_size = 32
history =
    datagen_train.flow(x_train, y_train, batch_size=batch_size, shuffle=True),
    validation_data = datagen_val.flow(x_val, y_val, batch_size=batch_size, shuffle=True),
    validation_steps = len(x_val)//batch_size,


Log-loss (cost function):
training   (min:    0.367, max:    0.564, cur:    0.368)
validation (min:    0.362, max:    5.084, cur:    0.362)

training   (min:    0.710, max:    0.764, cur:    0.756)
validation (min:    0.250, max:    0.751, cur:    0.743)
100/100 [==============================] - 184s 2s/step - loss: 0.3682 - accuracy: 0.7556 - val_loss: 0.3623 - val_accuracy: 0.7425

Evaluating The Model

Finally, we will evaluate the model with validation data. Here, we can find that the validation accuracy of the model is 75%.

model.evaluate(x_val, y_val)


[0.3621701712545473, 0.75125]

So now, let’s check the classification report of the model for true and predicted values.

from sklearn.metrics import confusion_matrix
from sklearn import metrics
import seaborn as sns

y_true = np.argmax(y_val, 1)
y_pred = np.argmax(model.predict(x_val), 1)
print(metrics.classification_report(y_true, y_pred))
print("Classification accuracy: %0.6f" % metrics.accuracy_score(y_true, y_pred))


                 precision    recall  f1-score   support

           0       1.00      0.99      0.99       200
           1       0.50      0.94      0.66       200
           2       0.54      0.07      0.13       200
           3       1.00      1.00      1.00       200

    accuracy                           0.75       800
   macro avg       0.76      0.75      0.70       800
weighted avg       0.76      0.75      0.70       800

Classification accuracy: 0.751250

For your reference, you can see the 4 different labels below which we used in our model.

labels = [“squiggle”, “narrowband”, “noise”, “narrowbanddrd”]

Thank you!


Leave a Reply

Your email address will not be published. Required fields are marked *