Signal Processing Conv1D.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "iMBMv7m4yutc"
   },
   "source": [
    "# **Loading Libraries**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 151
    },
    "colab_type": "code",
    "id": "SKn4HBwWyhNb",
    "outputId": "a846cf4a-e362-487d-ce49-366b741af8f6"
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense, Dropout, Flatten, Conv1D, MaxPool1D, BatchNormalization\n",
    "from keras.optimizers import Adam,RMSprop\n",
    "from keras.callbacks import ModelCheckpoint, History\n",
    "from keras.utils.np_utils import to_categorical\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from keras import regularizers\n",
    "\n",
    "from scipy import signal\n",
    "from scipy.signal import chirp, spectrogram\n",
    "import math\n",
    "import random as rd\n",
    "import tensorflow.compat.v1 as tf\n",
    "tf.disable_v2_behavior()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "YufgCHEXyzM8"
   },
   "source": [
    "# **Dataset Generation** \n",
    "\n",
    "Signal                      | Label         \n",
    ":---------------------------|:-------------:\n",
    "Continuous Wave             | 0             \n",
    "Bi-phase Shift Keying       | 1             \n",
    "Linear Frequency Modulation | 2             \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4J07Clrn2Pkf"
   },
   "outputs": [],
   "source": [
    "def LFM(t,f0,t1,f1,SNRdb):\n",
    "  noise = np.random.uniform(low=-1, high=1, size=(len(t),))\n",
    "  SNR = 10**(SNRdb/10);\n",
    "  A = math.sqrt(2*SNR);\n",
    "  signal = A*chirp(t, f0, t1, f1, method='linear', phi = rd.random()*math.pi) + noise\n",
    "  return signal\n",
    "\n",
    "def BPSK(t,position,freq,SNRdb):\n",
    "  phase = rd.random()*math.pi\n",
    "  phi = math.pi + phase\n",
    "  w = 2*math.pi*freq\n",
    "  SNR = 10**(SNRdb/10)\n",
    "  A = math.sqrt(2*SNR)\n",
    "  noise = np.random.uniform(low=-1, high=1, size=(len(t),))\n",
    "  signal = A*np.cos(w*t + phase) + noise\n",
    "  isegment= 256;    \n",
    "  jstart=1+isegment*3 + position;\n",
    "  jend=isegment*4 + position\n",
    "  shifted = A*np.cos(w*t+phi)\n",
    "  signal[jstart:jend]= shifted[jstart:jend] + noise[jstart:jend]\n",
    "  return signal\n",
    "\n",
    "def CW(t,freq,SNRdb):\n",
    "  phase = rd.random()*math.pi\n",
    "  w = 2*math.pi*freq\n",
    "  SNR = 10**(SNRdb/10)\n",
    "  A = math.sqrt(2*SNR)\n",
    "  noise = np.random.uniform(low=-1, high=1, size=(len(t),))\n",
    "  signal = A*np.cos(w*t+phase) + noise\n",
    "  return signal\n",
    "\n",
    "Ysig = []\n",
    "fs = 1280*1e6\n",
    "t = np.linspace(0, 1*1e-6, 1280)\n",
    "NFFT = 256\n",
    "start = 160*1e6\n",
    "finish = 185*1e6\n",
    "freq = 160*1e6\n",
    "freq_bin = np.arange(0, 1280, 5)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **Signal Plots**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 283
    },
    "colab_type": "code",
    "id": "SHPyJEHfkiq2",
    "outputId": "9f6a6205-2d62-4d13-a926-39236bb256f6"
   },
   "outputs": [],
   "source": [
    "plt.subplot(2,1,1)\n",
    "x = LFM(t,10e6,1e-6,100e6,100)/100000\n",
    "plt.plot(t*1e6,x)\n",
    "plt.title(\"Linear Frequency Modulation\")\n",
    "plt.ylabel(\"Amplitude\")\n",
    "plt.xlabel(\"Time (μs)\")\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.subplot(2,1,2)\n",
    "y = BPSK(t,128,50e6,100)/100000\n",
    "plt.plot(t*1e6,y)\n",
    "plt.title(\"Bi-phase Shift Keying\")\n",
    "plt.ylabel(\"Amplitude\")\n",
    "plt.xlabel(\"Time (μs)\");\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 231
    },
    "colab_type": "code",
    "id": "XNS9CFN78DxG",
    "outputId": "bbe99937-d770-4a65-ce49-5f8474577e03"
   },
   "outputs": [],
   "source": [
    "#train set generation\n",
    "Ysig = []\n",
    "window = signal.blackman(1280)\n",
    "for run in range(30000):\n",
    "  SNR = rd.randint(-10,10)\n",
    "  freq = rd.randint(100,600)*1e6\n",
    "  start = 160*1e6\n",
    "  finish = rd.randint(161,560)*1e6\n",
    "\n",
    "  signal1 = np.append(CW(t,freq,SNR),0)\n",
    "  Ysig.append(signal1)\n",
    "\n",
    "  signal1 = np.append(BPSK(t,0,freq,SNR),1)\n",
    "  Ysig.append(signal1)\n",
    "\n",
    "  signal1 = np.append(LFM(t,start,1e-6,finish,SNR),2)\n",
    "  Ysig.append(signal1)\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "V4zy_OgcdHvv"
   },
   "outputs": [],
   "source": [
    "#test set generation\n",
    "test_set = []\n",
    "test_labels = []\n",
    "\n",
    "for SNR in range(-10,11):\n",
    "  for run in range (100):\n",
    "    freq = rd.randint(100,600)*1e6\n",
    "    start = 160*1e6\n",
    "    finish = rd.randint(161,560)*1e6\n",
    "\n",
    "    signal1 = CW(t,freq,SNR)\n",
    "    test_set.append(signal1)\n",
    "    test_labels.append(0)\n",
    "\n",
    "    signal1 = BPSK(t,0,freq,SNR)\n",
    "    test_set.append(signal1)\n",
    "    test_labels.append(1)\n",
    "\n",
    "    signal1 = LFM(t,start,1e-6,finish,SNR)\n",
    "    test_set.append(signal1)\n",
    "    test_labels.append(2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "_fhBAOgbKzhu"
   },
   "outputs": [],
   "source": [
    "#Converted to excel file\n",
    "signals = pd.DataFrame(Ysig)\n",
    "signals.to_csv(\"train.csv\",index = False)\n",
    "\n",
    "signals = pd.DataFrame(test_set)\n",
    "signals.to_csv(\"test.csv\",index = False)\n",
    "\n",
    "signals = pd.DataFrame(test_labels)\n",
    "signals.to_csv(\"test_labels.csv\",index = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "FhoPGnLEkS6r"
   },
   "source": [
    "# Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ybx5bioZkXfI"
   },
   "outputs": [],
   "source": [
    "train = pd.read_csv(\"train.csv\")\n",
    "X_test = pd.read_csv(\"test.csv\")\n",
    "Y_test = pd.read_csv(\"test_labels.csv\")\n",
    "\n",
    "X_test = X_test.values.reshape((len(X_test),1280,1))\n",
    "Y_test = Y_test.values.reshape((len(Y_test),1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "B6clQ_P0lWEB"
   },
   "outputs": [],
   "source": [
    "Y_train = train[\"1280\"].astype(int)\n",
    "Y_train = to_categorical(Y_train, num_classes = 3)\n",
    "\n",
    "X_train = train.drop(labels = [\"1280\"],axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Ntr54TRMnifY"
   },
   "outputs": [],
   "source": [
    "random_seed = rd.randint(1,10)\n",
    "X_train, X_val, Y_train, Y_val = train_test_split(X_train, Y_train, test_size = 0.2, random_state=random_seed)\n",
    "X_train = X_train.values.reshape((len(X_train),1280,1))\n",
    "X_val = X_val.values.reshape((len(X_val),1280,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 224
    },
    "colab_type": "code",
    "id": "jvGVv6Kxp-oE",
    "outputId": "4e36bee6-696e-4505-b153-f7f3491075c1"
   },
   "outputs": [],
   "source": [
    "model = Sequential()\n",
    "\n",
    "model.add(Conv1D(filters = 32, kernel_size = 3,activation ='relu', input_shape = (1280,1)))\n",
    "model.add(Conv1D(filters = 32, kernel_size = 3, activation ='relu'))\n",
    "model.add(Dropout(0.4))\n",
    "\n",
    "model.add(Conv1D(filters = 32, kernel_size = 3,activation ='relu',kernel_regularizer=regularizers.l1(0.001)))\n",
    "model.add(Conv1D(filters = 32, kernel_size = 3, activation ='relu'))\n",
    "model.add(Dropout(0.4))\n",
    "\n",
    "model.add(Conv1D(filters = 64, kernel_size = 3, activation ='relu',kernel_regularizer=regularizers.l1(0.001)))\n",
    "model.add(Conv1D(filters = 64, kernel_size = 3, activation ='relu'))\n",
    "model.add(Dropout(0.4))\n",
    "\n",
    "\n",
    "model.add(Flatten())\n",
    "model.add(Dense(256, activation = \"relu\"))\n",
    "model.add(Dropout(0.5))\n",
    "model.add(Dense(3, activation = \"softmax\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 105
    },
    "colab_type": "code",
    "id": "_tFwHqM5ooi7",
    "outputId": "7f7a239e-8ae3-45fe-df76-e64d13ae2dc4"
   },
   "outputs": [],
   "source": [
    "# Define the optimizer\n",
    "optimizer = RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0)\n",
    "# Compile the model\n",
    "model.compile(optimizer = optimizer , loss = \"categorical_crossentropy\", metrics=[\"accuracy\"])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "colab_type": "code",
    "id": "z-Ed5_gOqXw3",
    "outputId": "6b9fa4a5-60ae-44a0-d2c0-64e1f6ef5808"
   },
   "outputs": [],
   "source": [
    "epoch = 200\n",
    "# Save model with best Val\n",
    "filepath=\"Best Weights.hdf5\"\n",
    "checkpoint = ModelCheckpoint(filepath, monitor='val_acc', verbose=1, save_best_only=True, mode='max')\n",
    "callbacks_list = [checkpoint, History()]\n",
    "# Fit the model\n",
    "history = model.fit(X_train,Y_train, batch_size= 1024,\n",
    "                    epochs = epoch, validation_data = (X_val,Y_val),\n",
    "                    callbacks=callbacks_list, verbose = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 295
    },
    "colab_type": "code",
    "id": "fdNb32tIzihf",
    "outputId": "5e51ac69-5133-4ef5-f243-e4521b85255d"
   },
   "outputs": [],
   "source": [
    "# Accuracy and Loss Plots\n",
    "plt.plot(history.history[\"acc\"])\n",
    "plt.plot(history.history[\"val_acc\"])\n",
    "plt.legend([\"train_acc\",\"val_acc\"])\n",
    "plt.title(\"Accuracy\")\n",
    "plt.xlabel(\"Epoch\")\n",
    "plt.ylabel(\"Accuracy\")\n",
    "plt.savefig(\"Accuracy\")\n",
    "plt.clf()\n",
    "\n",
    "plt.plot(history.history[\"loss\"])\n",
    "plt.plot(history.history[\"val_loss\"])\n",
    "plt.legend([\"train_loss\",\"val_loss\"])\n",
    "plt.title(\"Loss\")\n",
    "plt.xlabel(\"Epoch\")\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.savefig(\"Loss\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "BPkMjOL6lYcJ",
    "outputId": "e980023c-f3ed-46b3-f80e-d6452cec83e4"
   },
   "outputs": [],
   "source": [
    "# Evaluate against a test set\n",
    "signal = []\n",
    "y_pred = []\n",
    "y_actual = []\n",
    "correct = 0\n",
    "\n",
    "for index in range(0,len(X_test)):\n",
    "  signal =  np.expand_dims(X_test[index], axis = 0)\n",
    "  prediction = model.predict(signal)\n",
    "  y_pred.append(int(np.argmax(prediction)))\n",
    "  if np.argmax(prediction) == Y_test[index][0]:\n",
    "    correct += 1\n",
    "  \n",
    "\n",
    "accuracy = correct/len(X_test)\n",
    "\n",
    "print(\"accuracy:\", accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "OcK8iDjlquH-"
   },
   "outputs": [],
   "source": [
    "#Confusion matrix\n",
    "confusion_matrix = [[0,0,0],[0,0,0],[0,0,0]]\n",
    "y_pred = []\n",
    "y_actual = []\n",
    "signals = []\n",
    "\n",
    "for index in range(0,len(X_train)):\n",
    "  signals =  np.expand_dims(X_train[index], axis = 0)\n",
    "  prediction = model.predict(signals)\n",
    "  y_pred.append(int(np.argmax(prediction)))\n",
    "  y_actual.append(np.argmax(Y_train[index]))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 404
    },
    "colab_type": "code",
    "id": "7EsNKH4B6IUu",
    "outputId": "e699ed2d-fe50-4339-978a-e50ffee1b454"
   },
   "outputs": [],
   "source": [
    "y_pred = np.asarray(y_pred)\n",
    "y_actual = np.asarray(y_actual)\n",
    "matrix = confusion_matrix(y_actual, y_pred, labels=[0,1,2])\n",
    "\n",
    "#ax.set_xticklabels([\"CW\",\"BPSK\",\"LFM\"])\n",
    "fig, ax = plt.subplots(figsize=(6,6))\n",
    "for x in range(3):\n",
    "  for y in range(3):\n",
    "    ax.text(x,y,matrix[y][x], horizontalalignment='center')\n",
    "\n",
    "ax.set_xticklabels([\"\",\"CW\",\"\",\"BPSK\",\"\",\"LFM\"])\n",
    "ax.set_yticklabels([\"\",\"CW\",\"\",\"BPSK\",\"\",\"LFM\"])\n",
    "plt.title(\"Confusion Matrix\")\n",
    "plt.xlabel(\"Predicted\")\n",
    "plt.ylabel(\"True\")\n",
    "ax.imshow(matrix, cmap = plt.cm.Blues)\n",
    "plt.savefig(\"Confusion Matrix\")"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "machine_shape": "hm",
   "name": "Signal Processing Conv1D",
   "provenance": [],
   "toc_visible": true
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}