ECG_Analysis.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "ECG_Analysis.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/ndiekema/ecg_analysis/blob/main/ECG_Analysis.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yDMUhQR6ZFBO"
      },
      "source": [
        "# **ECG Medical Diagnosis Software**\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Cal Poly Senior Project - 2020-2021   \n",
        "Nathan Diekema & Hannah Chookaszian"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "McxwYz0TpZRg"
      },
      "source": [
        "Links to code that could be helpful:\n",
        "\n",
        "\n",
        "*   https://github.com/JackAndCole/ECG-Classification-Using-CNN-and-CWT\n",
        "*   \n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RhCnQrdp8uGq",
        "outputId": "9647e236-1639-416f-fa57-4d3d054559ca"
      },
      "source": [
        "pip install wfdb"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Collecting wfdb\n",
            "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/ee/28/21d6924727ff45c1ab0182d384e470fa5d1e985349528c4b807587b5da59/wfdb-3.4.0-py3-none-any.whl (137kB)\n",
            "\r\u001b[K     |██▍                             | 10kB 13.6MB/s eta 0:00:01\r\u001b[K     |████▊                           | 20kB 18.9MB/s eta 0:00:01\r\u001b[K     |███████▏                        | 30kB 22.4MB/s eta 0:00:01\r\u001b[K     |█████████▌                      | 40kB 24.6MB/s eta 0:00:01\r\u001b[K     |████████████                    | 51kB 21.7MB/s eta 0:00:01\r\u001b[K     |██████████████▎                 | 61kB 23.3MB/s eta 0:00:01\r\u001b[K     |████████████████▊               | 71kB 22.2MB/s eta 0:00:01\r\u001b[K     |███████████████████             | 81kB 22.1MB/s eta 0:00:01\r\u001b[K     |█████████████████████▍          | 92kB 20.8MB/s eta 0:00:01\r\u001b[K     |███████████████████████▉        | 102kB 20.6MB/s eta 0:00:01\r\u001b[K     |██████████████████████████▏     | 112kB 20.6MB/s eta 0:00:01\r\u001b[K     |████████████████████████████▋   | 122kB 20.6MB/s eta 0:00:01\r\u001b[K     |███████████████████████████████ | 133kB 20.6MB/s eta 0:00:01\r\u001b[K     |████████████████████████████████| 143kB 20.6MB/s \n",
            "\u001b[?25hRequirement already satisfied: scipy>=0.17.0 in /usr/local/lib/python3.7/dist-packages (from wfdb) (1.4.1)\n",
            "Collecting threadpoolctl>=1.0.0\n",
            "  Downloading https://files.pythonhosted.org/packages/f7/12/ec3f2e203afa394a149911729357aa48affc59c20e2c1c8297a60f33f133/threadpoolctl-2.1.0-py3-none-any.whl\n",
            "Requirement already satisfied: pytz>=2017.2 in /usr/local/lib/python3.7/dist-packages (from wfdb) (2018.9)\n",
            "Requirement already satisfied: python-dateutil>=2.4.2 in /usr/local/lib/python3.7/dist-packages (from wfdb) (2.8.1)\n",
            "Requirement already satisfied: requests>=2.8.1 in /usr/local/lib/python3.7/dist-packages (from wfdb) (2.23.0)\n",
            "Requirement already satisfied: cycler>=0.10.0 in /usr/local/lib/python3.7/dist-packages (from wfdb) (0.10.0)\n",
            "Requirement already satisfied: chardet>=3.0.0 in /usr/local/lib/python3.7/dist-packages (from wfdb) (3.0.4)\n",
            "Requirement already satisfied: scikit-learn>=0.18 in /usr/local/lib/python3.7/dist-packages (from wfdb) (0.22.2.post1)\n",
            "Requirement already satisfied: idna>=2.2 in /usr/local/lib/python3.7/dist-packages (from wfdb) (2.10)\n",
            "Requirement already satisfied: joblib>=0.11 in /usr/local/lib/python3.7/dist-packages (from wfdb) (1.0.1)\n",
            "Requirement already satisfied: pandas>=0.17.0 in /usr/local/lib/python3.7/dist-packages (from wfdb) (1.1.5)\n",
            "Requirement already satisfied: urllib3>=1.22 in /usr/local/lib/python3.7/dist-packages (from wfdb) (1.24.3)\n",
            "Requirement already satisfied: kiwisolver>=1.1.0 in /usr/local/lib/python3.7/dist-packages (from wfdb) (1.3.1)\n",
            "Requirement already satisfied: pyparsing>=2.0.4 in /usr/local/lib/python3.7/dist-packages (from wfdb) (2.4.7)\n",
            "Requirement already satisfied: matplotlib>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from wfdb) (3.2.2)\n",
            "Requirement already satisfied: numpy>=1.10.1 in /usr/local/lib/python3.7/dist-packages (from wfdb) (1.19.5)\n",
            "Requirement already satisfied: certifi>=2016.8.2 in /usr/local/lib/python3.7/dist-packages (from wfdb) (2021.5.30)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.4.2->wfdb) (1.15.0)\n",
            "Installing collected packages: threadpoolctl, wfdb\n",
            "Successfully installed threadpoolctl-2.1.0 wfdb-3.4.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e5QndFKfY9nV"
      },
      "source": [
        "import os\n",
        "import matplotlib.pyplot as plt\n",
        "import tensorflow as tf\n",
        "import scipy\n",
        "import scipy.signal\n",
        "import numpy as np\n",
        "import pywt\n",
        "from sklearn.metrics import classification_report, confusion_matrix\n",
        "import wfdb\n",
        "from tqdm import tqdm\n",
        "plt.rcParams[\"figure.figsize\"] = (20,4)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kCaN1F_kpvk9"
      },
      "source": [
        "**Load Data**\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hIDaqrwUE240",
        "outputId": "50111dfe-7876-4ea9-f42a-af6fa333b0d3"
      },
      "source": [
        "wfdb.dl_database('mitdb', 'data')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Generating record list for: 100\n",
            "Generating record list for: 101\n",
            "Generating record list for: 102\n",
            "Generating record list for: 103\n",
            "Generating record list for: 104\n",
            "Generating record list for: 105\n",
            "Generating record list for: 106\n",
            "Generating record list for: 107\n",
            "Generating record list for: 108\n",
            "Generating record list for: 109\n",
            "Generating record list for: 111\n",
            "Generating record list for: 112\n",
            "Generating record list for: 113\n",
            "Generating record list for: 114\n",
            "Generating record list for: 115\n",
            "Generating record list for: 116\n",
            "Generating record list for: 117\n",
            "Generating record list for: 118\n",
            "Generating record list for: 119\n",
            "Generating record list for: 121\n",
            "Generating record list for: 122\n",
            "Generating record list for: 123\n",
            "Generating record list for: 124\n",
            "Generating record list for: 200\n",
            "Generating record list for: 201\n",
            "Generating record list for: 202\n",
            "Generating record list for: 203\n",
            "Generating record list for: 205\n",
            "Generating record list for: 207\n",
            "Generating record list for: 208\n",
            "Generating record list for: 209\n",
            "Generating record list for: 210\n",
            "Generating record list for: 212\n",
            "Generating record list for: 213\n",
            "Generating record list for: 214\n",
            "Generating record list for: 215\n",
            "Generating record list for: 217\n",
            "Generating record list for: 219\n",
            "Generating record list for: 220\n",
            "Generating record list for: 221\n",
            "Generating record list for: 222\n",
            "Generating record list for: 223\n",
            "Generating record list for: 228\n",
            "Generating record list for: 230\n",
            "Generating record list for: 231\n",
            "Generating record list for: 232\n",
            "Generating record list for: 233\n",
            "Generating record list for: 234\n",
            "Generating list of all files for: 100\n",
            "Generating list of all files for: 101\n",
            "Generating list of all files for: 102\n",
            "Generating list of all files for: 103\n",
            "Generating list of all files for: 104\n",
            "Generating list of all files for: 105\n",
            "Generating list of all files for: 106\n",
            "Generating list of all files for: 107\n",
            "Generating list of all files for: 108\n",
            "Generating list of all files for: 109\n",
            "Generating list of all files for: 111\n",
            "Generating list of all files for: 112\n",
            "Generating list of all files for: 113\n",
            "Generating list of all files for: 114\n",
            "Generating list of all files for: 115\n",
            "Generating list of all files for: 116\n",
            "Generating list of all files for: 117\n",
            "Generating list of all files for: 118\n",
            "Generating list of all files for: 119\n",
            "Generating list of all files for: 121\n",
            "Generating list of all files for: 122\n",
            "Generating list of all files for: 123\n",
            "Generating list of all files for: 124\n",
            "Generating list of all files for: 200\n",
            "Generating list of all files for: 201\n",
            "Generating list of all files for: 202\n",
            "Generating list of all files for: 203\n",
            "Generating list of all files for: 205\n",
            "Generating list of all files for: 207\n",
            "Generating list of all files for: 208\n",
            "Generating list of all files for: 209\n",
            "Generating list of all files for: 210\n",
            "Generating list of all files for: 212\n",
            "Generating list of all files for: 213\n",
            "Generating list of all files for: 214\n",
            "Generating list of all files for: 215\n",
            "Generating list of all files for: 217\n",
            "Generating list of all files for: 219\n",
            "Generating list of all files for: 220\n",
            "Generating list of all files for: 221\n",
            "Generating list of all files for: 222\n",
            "Generating list of all files for: 223\n",
            "Generating list of all files for: 228\n",
            "Generating list of all files for: 230\n",
            "Generating list of all files for: 231\n",
            "Generating list of all files for: 232\n",
            "Generating list of all files for: 233\n",
            "Generating list of all files for: 234\n",
            "Created local base download directory: data\n",
            "Downloading files...\n",
            "Finished downloading files\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PSgZYP8smfKa",
        "outputId": "31849a23-0a19-4f64-831d-8d6d468762a8"
      },
      "source": [
        "!zip -r /content/mitdb.zip /content/data"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "  adding: content/data/ (stored 0%)\n",
            "  adding: content/data/115.hea (deflated 28%)\n",
            "  adding: content/data/220.dat (deflated 40%)\n",
            "  adding: content/data/205.dat (deflated 43%)\n",
            "  adding: content/data/232.dat (deflated 34%)\n",
            "  adding: content/data/212.dat (deflated 23%)\n",
            "  adding: content/data/201.dat (deflated 42%)\n",
            "  adding: content/data/231.hea (deflated 30%)\n",
            "  adding: content/data/104.atr (deflated 40%)\n",
            "  adding: content/data/103.hea (deflated 23%)\n",
            "  adding: content/data/122.hea (deflated 26%)\n",
            "  adding: content/data/116.hea (deflated 26%)\n",
            "  adding: content/data/112.hea (deflated 26%)\n",
            "  adding: content/data/104.dat (deflated 30%)\n",
            "  adding: content/data/200.dat (deflated 28%)\n",
            "  adding: content/data/112.atr (deflated 56%)\n",
            "  adding: content/data/101.hea (deflated 29%)\n",
            "  adding: content/data/207.atr (deflated 37%)\n",
            "  adding: content/data/228.dat (deflated 24%)\n",
            "  adding: content/data/208.dat (deflated 25%)\n",
            "  adding: content/data/215.hea (deflated 28%)\n",
            "  adding: content/data/221.dat (deflated 32%)\n",
            "  adding: content/data/230.atr (deflated 46%)\n",
            "  adding: content/data/100.hea (deflated 28%)\n",
            "  adding: content/data/214.atr (deflated 35%)\n",
            "  adding: content/data/200.hea (deflated 32%)\n",
            "  adding: content/data/121.atr (deflated 45%)\n",
            "  adding: content/data/217.hea (deflated 25%)\n",
            "  adding: content/data/217.dat (deflated 23%)\n",
            "  adding: content/data/220.atr (deflated 45%)\n",
            "  adding: content/data/222.atr (deflated 35%)\n",
            "  adding: content/data/213.dat (deflated 17%)\n",
            "  adding: content/data/202.dat (deflated 35%)\n",
            "  adding: content/data/215.atr (deflated 47%)\n",
            "  adding: content/data/100.dat (deflated 41%)\n",
            "  adding: content/data/207.hea (deflated 39%)\n",
            "  adding: content/data/230.dat (deflated 29%)\n",
            "  adding: content/data/217.atr (deflated 39%)\n",
            "  adding: content/data/205.hea (deflated 28%)\n",
            "  adding: content/data/103.atr (deflated 46%)\n",
            "  adding: content/data/107.atr (deflated 52%)\n",
            "  adding: content/data/230.hea (deflated 29%)\n",
            "  adding: content/data/219.atr (deflated 31%)\n",
            "  adding: content/data/114.atr (deflated 39%)\n",
            "  adding: content/data/115.dat (deflated 34%)\n",
            "  adding: content/data/114.hea (deflated 26%)\n",
            "  adding: content/data/122.atr (deflated 50%)\n",
            "  adding: content/data/102.dat (deflated 24%)\n",
            "  adding: content/data/233.dat (deflated 21%)\n",
            "  adding: content/data/115.atr (deflated 39%)\n",
            "  adding: content/data/123.atr (deflated 35%)\n",
            "  adding: content/data/105.hea (deflated 28%)\n",
            "  adding: content/data/207.dat (deflated 26%)\n",
            "  adding: content/data/233.hea (deflated 25%)\n",
            "  adding: content/data/108.hea (deflated 30%)\n",
            "  adding: content/data/205.atr (deflated 52%)\n",
            "  adding: content/data/108.atr (deflated 34%)\n",
            "  adding: content/data/223.atr (deflated 39%)\n",
            "  adding: content/data/209.hea (deflated 27%)\n",
            "  adding: content/data/119.dat (deflated 28%)\n",
            "  adding: content/data/105.atr (deflated 44%)\n",
            "  adding: content/data/102.hea (deflated 29%)\n",
            "  adding: content/data/215.dat (deflated 28%)\n",
            "  adding: content/data/208.atr (deflated 44%)\n",
            "  adding: content/data/105.dat (deflated 27%)\n",
            "  adding: content/data/213.atr (deflated 50%)\n",
            "  adding: content/data/106.dat (deflated 28%)\n",
            "  adding: content/data/123.dat (deflated 35%)\n",
            "  adding: content/data/214.hea (deflated 29%)\n",
            "  adding: content/data/234.atr (deflated 56%)\n",
            "  adding: content/data/200.atr (deflated 44%)\n",
            "  adding: content/data/203.dat (deflated 21%)\n",
            "  adding: content/data/111.hea (deflated 30%)\n",
            "  adding: content/data/219.hea (deflated 29%)\n",
            "  adding: content/data/109.hea (deflated 27%)\n",
            "  adding: content/data/106.atr (deflated 39%)\n",
            "  adding: content/data/114.dat (deflated 30%)\n",
            "  adding: content/data/102.atr (deflated 49%)\n",
            "  adding: content/data/203.atr (deflated 30%)\n",
            "  adding: content/data/101.atr (deflated 42%)\n",
            "  adding: content/data/234.dat (deflated 32%)\n",
            "  adding: content/data/118.dat (deflated 23%)\n",
            "  adding: content/data/112.dat (deflated 36%)\n",
            "  adding: content/data/228.atr (deflated 37%)\n",
            "  adding: content/data/109.dat (deflated 27%)\n",
            "  adding: content/data/121.dat (deflated 32%)\n",
            "  adding: content/data/111.atr (deflated 48%)\n",
            "  adding: content/data/209.dat (deflated 31%)\n",
            "  adding: content/data/210.atr (deflated 33%)\n",
            "  adding: content/data/212.atr (deflated 44%)\n",
            "  adding: content/data/213.hea (deflated 34%)\n",
            "  adding: content/data/123.hea (deflated 25%)\n",
            "  adding: content/data/232.atr (deflated 38%)\n",
            "  adding: content/data/111.dat (deflated 26%)\n",
            "  adding: content/data/212.hea (deflated 29%)\n",
            "  adding: content/data/124.atr (deflated 38%)\n",
            "  adding: content/data/202.atr (deflated 34%)\n",
            "  adding: content/data/202.hea (deflated 29%)\n",
            "  adding: content/data/101.dat (deflated 41%)\n",
            "  adding: content/data/210.hea (deflated 26%)\n",
            "  adding: content/data/222.hea (deflated 30%)\n",
            "  adding: content/data/214.dat (deflated 24%)\n",
            "  adding: content/data/210.dat (deflated 35%)\n",
            "  adding: content/data/223.dat (deflated 28%)\n",
            "  adding: content/data/119.hea (deflated 23%)\n",
            "  adding: content/data/124.dat (deflated 29%)\n",
            "  adding: content/data/107.dat (deflated 16%)\n",
            "  adding: content/data/117.dat (deflated 32%)\n",
            "  adding: content/data/221.hea (deflated 28%)\n",
            "  adding: content/data/116.dat (deflated 26%)\n",
            "  adding: content/data/117.hea (deflated 29%)\n",
            "  adding: content/data/209.atr (deflated 44%)\n",
            "  adding: content/data/231.atr (deflated 63%)\n",
            "  adding: content/data/223.hea (deflated 27%)\n",
            "  adding: content/data/106.hea (deflated 25%)\n",
            "  adding: content/data/201.hea (deflated 26%)\n",
            "  adding: content/data/113.dat (deflated 29%)\n",
            "  adding: content/data/234.hea (deflated 26%)\n",
            "  adding: content/data/113.atr (deflated 37%)\n",
            "  adding: content/data/117.atr (deflated 47%)\n",
            "  adding: content/data/219.dat (deflated 24%)\n",
            "  adding: content/data/100.atr (deflated 47%)\n",
            "  adding: content/data/121.hea (deflated 25%)\n",
            "  adding: content/data/232.hea (deflated 32%)\n",
            "  adding: content/data/228.hea (deflated 30%)\n",
            "  adding: content/data/104.hea (deflated 34%)\n",
            "  adding: content/data/231.dat (deflated 34%)\n",
            "  adding: content/data/103.dat (deflated 31%)\n",
            "  adding: content/data/109.atr (deflated 48%)\n",
            "  adding: content/data/122.dat (deflated 29%)\n",
            "  adding: content/data/233.atr (deflated 41%)\n",
            "  adding: content/data/220.hea (deflated 27%)\n",
            "  adding: content/data/201.atr (deflated 26%)\n",
            "  adding: content/data/203.hea (deflated 34%)\n",
            "  adding: content/data/116.atr (deflated 51%)\n",
            "  adding: content/data/208.hea (deflated 33%)\n",
            "  adding: content/data/107.hea (deflated 26%)\n",
            "  adding: content/data/119.atr (deflated 42%)\n",
            "  adding: content/data/222.dat (deflated 34%)\n",
            "  adding: content/data/113.hea (deflated 29%)\n",
            "  adding: content/data/118.atr (deflated 43%)\n",
            "  adding: content/data/108.dat (deflated 23%)\n",
            "  adding: content/data/124.hea (deflated 26%)\n",
            "  adding: content/data/118.hea (deflated 23%)\n",
            "  adding: content/data/221.atr (deflated 36%)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mIdJWzbm98cb"
      },
      "source": [
        "# **Preprocessing**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AZpDzU8qpt72",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 591
        },
        "outputId": "c96379fe-9dd1-4b3a-ae7e-35fa8e7f0c77"
      },
      "source": [
        "import scipy.signal\n",
        "\n",
        "sampling_rate = 360 # MIT-BIH ECG records are captured at 360Hz\n",
        "raw_sig101 = wfdb.rdrecord('data/101', channels = [0], sampto = sampling_rate*30)\n",
        "\n",
        "plt.plot(raw_sig101.p_signal[:,0])\n",
        "plt.title('Signal Before Preprocessing')\n",
        "plt.xlabel('Sample')\n",
        "plt.ylabel('Amplitude (V)')\n",
        "\n",
        "# Eliminate baseline wander\n",
        "b, a = scipy.signal.butter(N=2, Wn=0.5, btype='highpass', analog=False, output='ba', fs=sampling_rate)\n",
        "output1 = scipy.signal.filtfilt(b, a, raw_sig101.p_signal[:,0])\n",
        "\n",
        "# Reduce Powerline Interference \n",
        "# Notch filter centered at 60 Hz\n",
        "plt.figure()\n",
        "b2, a2 = scipy.signal.iirnotch(w0=60.0, Q=30.0, fs=360.0)\n",
        "output2 = scipy.signal.filtfilt(b2, a2, output1)\n",
        "plt.plot(output2, color='orange')\n",
        "plt.title('Signal After Preprocessing')\n",
        "plt.xlabel('Sample')\n",
        "plt.ylabel('Amplitude (V)')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0, 0.5, 'Amplitude (V)')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 33
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mxUMJhVYKu1p"
      },
      "source": [
        "# Declare struct to hold important signal data\n",
        "class Signal:\n",
        "  def __init__(self, record, signal, r_peaks, labels):\n",
        "    self.record = record # Record number\n",
        "    self.signal = signal\n",
        "    self.r_peaks = r_peaks\n",
        "    self.labels = labels "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3byjox1_f_vY"
      },
      "source": [
        "\"\"\"\n",
        "The data is provided by \n",
        "https://physionet.org/physiobank/database/html/mitdbdir/mitdbdir.htm\n",
        "The recordings were digitized at 360 samples per second per channel with 11-bit resolution over a 10 mV range.\n",
        "Two or more cardiologists independently annotated each record; disagreements were resolved to obtain the computer-readable\n",
        "reference annotations for each beat (approximately 110,000 annotations in all) included with the database.\n",
        "    Code\t\tDescription\n",
        "    N\t\tNormal beat (displayed as . by the PhysioBank ATM, LightWAVE, pschart, and psfd)\n",
        "    L\t\tLeft bundle branch block beat\n",
        "    R\t\tRight bundle branch block beat\n",
        "    B\t\tBundle branch block beat (unspecified)\n",
        "    A\t\tAtrial premature beat\n",
        "    a\t\tAberrated atrial premature beat\n",
        "    J\t\tNodal (junctional) premature beat\n",
        "    S\t\tSupraventricular premature or ectopic beat (atrial or nodal)\n",
        "    V\t\tPremature ventricular contraction\n",
        "    r\t\tR-on-T premature ventricular contraction\n",
        "    F\t\tFusion of ventricular and normal beat\n",
        "    e\t\tAtrial escape beat\n",
        "    j\t\tNodal (junctional) escape beat\n",
        "    n\t\tSupraventricular escape beat (atrial or nodal)\n",
        "    E\t\tVentricular escape beat\n",
        "    /\t\tPaced beat\n",
        "    f\t\tFusion of paced and normal beat\n",
        "    Q\t\tUnclassifiable beat\n",
        "    ?\t\tBeat not classified during learning\n",
        "\"\"\"\n",
        "\n",
        "# These are the classes that we wish to remove in the preprocessing stage\n",
        "# since they do not refer to a particular beat type.\n",
        "invalid_labels = ['|', # Isolated QRS-like artifact\n",
        "                  '~', # Change in signal quality\n",
        "                  '!', # Ventricular flutter wave\n",
        "                  '+', # Rhythm change\n",
        "                  '[', # Start of ventricular flutter/fibrillation\n",
        "                  ']', # End of ventricular flutter/fibrillation\n",
        "                  '\"', # Comment annotation\n",
        "                  'x'  # Non-conducted P-wave (blocked APC)\n",
        "                  ]\n",
        "\n",
        "# These are the beat types our program will be classifying\n",
        "valid_classes = ['N', # Normal beat \n",
        "                 'L', #\tLeft bundle branch block beat\n",
        "                 'R', # Right bundle branch block beat\n",
        "                 'V', # Premature ventricular contraction\n",
        "                 'A', # Atrial premature beat\n",
        "                 '/', # Paced Beat\n",
        "                 ]\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tV-kGW5Fcllj"
      },
      "source": [
        "# Adapted from: https://github.com/JackAndCole/ECG-Classification-Using-CNN-and-CWT/blob/master/preprocessing.py\n",
        "def process_record(record):\n",
        "  \"\"\"\n",
        "    Input: An integer representing one of the ECG records from the MIT-BIH \n",
        "      database\n",
        "    Output: A Signal object with the record number, signal data, r_peak data,\n",
        "      and relevant annotations.\n",
        "    Description: This function is responsible for the initial preprocessing of\n",
        "      the ECG signals. It handles the denoising of the input signal by applying\n",
        "      a butterworth filter (to eliminate baseline wander) and a notch filter \n",
        "      (to mitigate powerline interference). It also filters out any unwanted \n",
        "      annotations and adjusts the R-peak locations to ensure maximum accuracy.\n",
        "  \"\"\"\n",
        "  raw_signal = wfdb.rdrecord(f'data/{record}', channels = [0]).p_signal[:,0] # MLII signal only\n",
        "  annotation = wfdb.rdann(f'data/{record}', extension='atr')\n",
        "\n",
        "  r_peaks = annotation.sample\n",
        "  labels = np.array(annotation.symbol)\n",
        "\n",
        "  # Eliminate baseline wander\n",
        "  # Butterworth high-pass filter with an fc=0.5Hz\n",
        "  b, a = scipy.signal.butter(N=2, Wn=0.5, btype='highpass', \n",
        "                             analog=False, output='ba', fs=sampling_rate)\n",
        "  signal = scipy.signal.filtfilt(b, a, raw_signal)\n",
        "\n",
        "  # Med filter\n",
        "  # baseline = scipy.signal.medfilt(raw_signal, int(0.2 * sampling_rate - 1))\n",
        "  # baseline = scipy.signal.medfilt(baseline, int(0.6 * sampling_rate - 1))\n",
        "  # signal = raw_signal - baseline\n",
        "\n",
        "\n",
        "  # Reduce Powerline Interference \n",
        "  # Notch filter centered at 60 Hz\n",
        "  b, a = scipy.signal.iirnotch(w0=60.0, Q=30.0, fs=360.0)\n",
        "  signal = scipy.signal.filtfilt(b, a, signal)\n",
        "\n",
        "  # Remove unwanted beats\n",
        "  indices = [i for (i, label) in enumerate(labels) if label not in invalid_labels]\n",
        "  r_peaks, labels = r_peaks[indices], labels[indices]\n",
        "\n",
        "  # Align the signals r_peaks to maximize accuracy\n",
        "  aligned_peaks = []\n",
        "  for r_peak in r_peaks:\n",
        "    r_left = np.maximum(r_peak - int(.05 * sampling_rate), 0)\n",
        "    r_right = np.minimum(r_peak + int(.05 * sampling_rate), len(signal))\n",
        "    aligned_peaks.append(r_left + np.argmax(signal[r_left:r_right]))\n",
        "\n",
        "  r_peaks = np.array(aligned_peaks, dtype=\"int\")\n",
        "\n",
        "  # Normalize signal amplitudes across all patients\n",
        "  # Note: Could also try using sklearn.preprocessing.StandardScaler\n",
        "  signal = signal / np.mean(signal[r_peaks])\n",
        "  \n",
        "  # Return an object with all relevant signal data & annotations\n",
        "  return Signal(record, signal, r_peaks, labels)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "cellView": "form",
        "id": "CJYcY_vwscsp",
        "outputId": "28d28654-e099-4561-ebb4-8e054dcb48ca"
      },
      "source": [
        "#@title Default title text\n",
        "split = True #@param {type:\"boolean\"}\n",
        "\n",
        "print(split)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f9afVJJbK8jE"
      },
      "source": [
        "import pickle\n",
        "import scipy.signal\n",
        "\n",
        "train_ds = []\n",
        "test_ds = []\n",
        "\n",
        "if split == False:\n",
        "\n",
        "  all_records = [100, 103, 105, 107, 111, 113, 117, 121, 123, 200, 202, 210, \n",
        "                212, 213, 214, 219, 221, 222, 228, 231, 232, 233, 234,\n",
        "                101, 102, 106, 108, 109, 112, 114, 115, 116, 118, 119, 122, \n",
        "                124, 201, 203, 205, 207, 208, 209, 215, 220, 223, 230]\n",
        "\n",
        "  for record_num in all_records:\n",
        "    signal_data = process_record(record_num)\n",
        "    train_ds.append(signal_data)\n",
        "\n",
        "# Optional - Store data in gdrive\n",
        "# save_path = \"/content/drive/ECG_Classifier/preprocessed_mitdb.p\"\n",
        "# pickle.dump((train_ds, test_ds), open(save_path, \"wb\"))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Fv_qyY-aq569"
      },
      "source": [
        "if split == True:\n",
        "  train_records = [101, 102, 106, 108, 109, 112, 114, 115, 116, 118, 119, 122, \n",
        "              124, 201, 203, 205, 207, 208, 209, 215, 220, 223, 230]\n",
        "\n",
        "  test_records = [100, 103, 105, 107, 111, 113, 117, 121, 123, 200, 202, 210, \n",
        "            212, 213, 214, 219, 221, 222, 228, 231, 232, 233, 234]\n",
        "            \n",
        "  for record_num in train_records:\n",
        "    signal_data = process_record(record_num)\n",
        "    train_ds.append(signal_data)\n",
        "\n",
        "  for record_num in test_records:\n",
        "    signal_data = process_record(record_num)\n",
        "    test_ds.append(signal_data)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "r7eQujPPaN-0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 90
        },
        "outputId": "af949723-f21b-4c36-c920-ee713c5862a8"
      },
      "source": [
        "# Visualize a waveform\n",
        "# First 10 seconds of record '105'\n",
        "\n",
        "view_signal = train_ds[12]\n",
        "view_len = sampling_rate*10\n",
        "\n",
        "plt.plot(range(view_len), view_signal.signal[0:view_len])\n",
        "plt.title('Record {}'.format(view_signal.record))\n",
        "print('Beat Types:', view_signal.labels[0:10], '\\n')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Beat Types: ['R' 'R' 'R' 'R' 'R' 'R' 'R' 'R' 'R' 'R'] \n",
            "\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k3ejn94mKCTQ",
        "outputId": "cfc48acd-4f66-4169-9348-0a781032b9d1"
      },
      "source": [
        "# Entire dataset beat distribution\n",
        "print('Dataset Beat Distribution:')\n",
        "total_sum = 0\n",
        "for vc in valid_classes:\n",
        "  sum = 0\n",
        "  for sig_data in train_ds:\n",
        "    for beat_label in sig_data.labels:\n",
        "      if beat_label == vc:\n",
        "        sum += 1\n",
        "        total_sum += 1\n",
        "  print(f'  {vc} - {sum}')\n",
        "print(f'Total: {total_sum}')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Dataset Beat Distribution:\n",
            "  N - 38201\n",
            "  L - 3949\n",
            "  R - 3783\n",
            "  V - 3687\n",
            "  A - 810\n",
            "  / - 2028\n",
            "Total: 52458\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bC0bW5vJYnIa"
      },
      "source": [
        "# **Feature Extraction**\n",
        "\n",
        "*Note: RR ~ R-peak interval*\n",
        "\n",
        "1.   Discrete Wavelet Transform (DWT)\n",
        "2.   RR Intervals\n",
        "\n",
        "Note: beats with RR not within a certain window most likely have segmentation errors and should be discarded. [1]\n",
        "\n",
        "[1] https://github.com/mondejar/ecg-classification\n",
        "\n",
        "check this out \n",
        "https://medium.com/@andrewtan_36013/electrocardiograms-qrs-detection-using-wavelet-analysis-a1070505efee\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f-h_iLKg92-F"
      },
      "source": [
        "# Helper functions for extracting features from DWT\n",
        "def select_coeffs(coeffs):\n",
        "  features = []\n",
        "  for c in coeffs:\n",
        "    features.append(np.mean(c))\n",
        "    features.append(np.std(c))\n",
        "    features.append(max(c))\n",
        "    features.append(min(c))\n",
        "\n",
        "  return np.array(features)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5xkClR0HYOkr"
      },
      "source": [
        "import cv2\n",
        "import pywt\n",
        "import random\n",
        "sampling_rate = 360\n",
        "\n",
        "def extract_features(signal_data):\n",
        "  \"\"\"\n",
        "    Input: Dict containing all information from a \n",
        "    Output: A tuple consisting of a \n",
        "    Description: This function \n",
        "  \"\"\"\n",
        "  r_peaks = signal_data.r_peaks\n",
        "  labels = signal_data.labels\n",
        "  signal = signal_data.signal\n",
        "  leading_buf, lagging_buf = 90, 110\n",
        "  valid_classes = ['N', 'L', 'R', 'V', 'A', '/']\n",
        "\n",
        "  avg_RR = np.mean(np.diff(r_peaks)) # For removal of inter-patient variability\n",
        "  wavelets, intervals_RR, classes = [], [], []\n",
        "  global_RR = 0\n",
        "\n",
        "  # Cycle through all of the beats in the signal\n",
        "  # (Skip the first and last beat)\n",
        "  for i in range(1, len(r_peaks) - 1):\n",
        "\n",
        "    # Skip all invalid classes of beats\n",
        "    if labels[i] not in valid_classes:\n",
        "      continue\n",
        "    \n",
        "    # Normalize the surplus number of normal beats\n",
        "    if labels[i] == 'N':\n",
        "      if random.random() > 0.2:\n",
        "        continue\n",
        "\n",
        "    # ===== Discrete Wavelet Transform =====\n",
        "    coeffs = pywt.wavedec(signal[r_peaks[i] - leading_buf : r_peaks[i] + lagging_buf], wavelet='db2', mode='perdiodization', level=3)[0]\n",
        "\n",
        "    # ======= RR intervals =======\n",
        "    pre_RR = r_peaks[i] - r_peaks[i - 1]\n",
        "    post_RR = r_peaks[i + 1] - r_peaks[i] \n",
        "    local_RR = np.mean(np.diff((r_peaks[max(0,i-10):i + 1])))\n",
        "    global_RR += pre_RR\n",
        "\n",
        "    # Check for segmentation errors:\n",
        "    if local_RR > (2 * sampling_rate) or local_RR < (0.15 < sampling_rate):\n",
        "      continue\n",
        "\n",
        "    wavelets.append(coeffs)\n",
        "    classes.append(labels[i])\n",
        "    intervals_RR.append([pre_RR - avg_RR, post_RR - avg_RR, local_RR - avg_RR])\n",
        "\n",
        "  global_RR = global_RR/len(intervals_RR)\n",
        "  for i in range(len(intervals_RR)):\n",
        "    intervals_RR[i].append(global_RR)\n",
        "\n",
        "\n",
        "  return (wavelets, intervals_RR, classes)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UqLOgrxsYmdR",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 584
        },
        "outputId": "a3e86e9c-6699-4b09-fb36-2adef5f9d313"
      },
      "source": [
        "from sklearn.model_selection import train_test_split  # Use for splitting training/validation datasets\n",
        "\n",
        "x1_train, x1_test = [], []\n",
        "x2_train, x2_test = [], []\n",
        "y_train, y_test = [], []\n",
        "\n",
        "# For training set\n",
        "for signal_data in train_ds:\n",
        "  wavelets, intervals_RR, classes = extract_features(signal_data)\n",
        "  x1_train.append(wavelets)\n",
        "  x2_train.append(intervals_RR)\n",
        "  y_train.append(classes)\n",
        "\n",
        "#  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n",
        "# For testing set\n",
        "for signal_data in test_ds:\n",
        "  wavelets, intervals_RR, classes = extract_features(signal_data)\n",
        "  x1_test.append(wavelets)\n",
        "  x2_test.append(intervals_RR)\n",
        "  y_test.append(classes)\n",
        "\n",
        "x1_test = np.concatenate(x1_test, axis=0).astype('float32')\n",
        "x2_test = np.concatenate(x2_test, axis=0).astype('float32')\n",
        "y_test = np.concatenate(y_test, axis=0)\n",
        "y_test = np.array([valid_classes.index(k) for k in y_test]).astype('int64')\n",
        "#  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n",
        "\n",
        "x1_train = np.concatenate(x1_train, axis=0).astype('float32')\n",
        "x2_train = np.concatenate(x2_train, axis=0).astype('float32')\n",
        "y_train = np.concatenate(y_train, axis=0)\n",
        "y_train = np.array([valid_classes.index(k) for k in y_train]).astype('int64')\n",
        "\n",
        "# Validation set\n",
        "x1_train, x1_val, x2_train, x2_val, y_train, y_val = train_test_split(x1_train, \n",
        "                                                                   x2_train, \n",
        "                                                                   y_train, \n",
        "                                                                   test_size=0.1, \n",
        "                                                                   shuffle=True, \n",
        "                                                                   random_state=42,\n",
        "                                                                   stratify=y_train) \n",
        "\n",
        "print(\"Training Size: \", len(y_train))\n",
        "print(\"Validation Size: \", len(y_val))\n",
        "print(\"Testing Size: \", len(y_test))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32mpywt/_extensions/_pywt.pyx\u001b[0m in \u001b[0;36mpywt._extensions._pywt._Modes.from_object\u001b[0;34m()\u001b[0m\n",
            "\u001b[0;32mpywt/_extensions/_pywt.pyx\u001b[0m in \u001b[0;36mpywt._extensions._pywt._Modes.__getattr__\u001b[0;34m()\u001b[0m\n",
            "\u001b[0;31mAttributeError\u001b[0m: '_Modes' object has no attribute 'perdiodization'",
            "\nDuring handling of the above exception, another exception occurred:\n",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-44-aa4ab8476f14>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;31m# For training set\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0msignal_data\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mtrain_ds\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m   \u001b[0mwavelets\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mintervals_RR\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mclasses\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mextract_features\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msignal_data\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     10\u001b[0m   \u001b[0mx1_train\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwavelets\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m   \u001b[0mx2_train\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mintervals_RR\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-43-664398fa5ec2>\u001b[0m in \u001b[0;36mextract_features\u001b[0;34m(signal_data)\u001b[0m\n\u001b[1;32m     34\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     35\u001b[0m     \u001b[0;31m# ===== Discrete Wavelet Transform =====\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 36\u001b[0;31m     \u001b[0mcoeffs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpywt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwavedec\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msignal\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mr_peaks\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mleading_buf\u001b[0m \u001b[0;34m:\u001b[0m \u001b[0mr_peaks\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mlagging_buf\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mwavelet\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'db2'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmode\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'perdiodization'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlevel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     37\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     38\u001b[0m     \u001b[0;31m# ======= RR intervals =======\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/pywt/_multilevel.py\u001b[0m in \u001b[0;36mwavedec\u001b[0;34m(data, wavelet, mode, level, axis)\u001b[0m\n\u001b[1;32m    101\u001b[0m     \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    102\u001b[0m     \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlevel\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 103\u001b[0;31m         \u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdwt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mwavelet\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmode\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    104\u001b[0m         \u001b[0mcoeffs_list\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0md\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    105\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/pywt/_dwt.py\u001b[0m in \u001b[0;36mdwt\u001b[0;34m(data, wavelet, mode, axis)\u001b[0m\n\u001b[1;32m    171\u001b[0m     \u001b[0mdt\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_check_dtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    172\u001b[0m     \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0morder\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'C'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 173\u001b[0;31m     \u001b[0mmode\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mModes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrom_object\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    174\u001b[0m     \u001b[0mwavelet\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_as_wavelet\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwavelet\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    175\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32mpywt/_extensions/_pywt.pyx\u001b[0m in \u001b[0;36mpywt._extensions._pywt._Modes.from_object\u001b[0;34m()\u001b[0m\n",
            "\u001b[0;31mValueError\u001b[0m: Unknown mode name 'perdiodization'."
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xG7kRCs7zqS-"
      },
      "source": [
        "from imblearn.under_sampling import RandomUnderSampler\n",
        "\n",
        "# Undersample the testing dataset\n",
        "def sampling_strategy(n_samples):\n",
        "    #target_classes_all = y.value_counts().index\n",
        "    targets = range(len(valid_classes))\n",
        "    sampling_strategy = {}\n",
        "    for target in targets:\n",
        "        sampling_strategy[target] = n_samples\n",
        "    return sampling_strategy\n",
        "\n",
        "undersample = RandomUnderSampler(sampling_strategy=sampling_strategy(500), \n",
        "                                 random_state = 42)\n",
        "\n",
        "# x1_test, _ = undersample.fit_resample(x1_test, y_test)\n",
        "# x2_test, y_test = undersample.fit_resample(x2_test, y_test)\n",
        "x1_test, _ = undersample.fit_resample(x1_train, y_train)\n",
        "x2_test, y_test = undersample.fit_resample(x2_train, y_train)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fjOlHM9Ke_9-"
      },
      "source": [
        "train_size = len(y_train)\n",
        "val_size = len(y_val)\n",
        "test_size = len(y_test)\n",
        "\n",
        "print(f'Size of Training Dataset: {train_size}')\n",
        "print('Distribution:')\n",
        "for vc in valid_classes:\n",
        "  sum = 0\n",
        "  for beat_label in y_train:\n",
        "    if valid_classes[beat_label] == vc:\n",
        "      sum += 1\n",
        "  print(f'  {vc} - {sum}')\n",
        "\n",
        "print(f'\\nSize of Validation Dataset: {val_size}')\n",
        "print('Distribution:')\n",
        "for vc in valid_classes:\n",
        "  sum = 0\n",
        "  for beat_label in y_val:\n",
        "    if valid_classes[beat_label] == vc:\n",
        "      sum += 1\n",
        "  print(f'  {vc} - {sum}')\n",
        "\n",
        "print(f'\\nSize of Testing Dataset: {test_size}')\n",
        "# Training dataset distribution\n",
        "print('Distribution:')\n",
        "for vc in valid_classes:\n",
        "  sum = 0\n",
        "  for beat_label in y_test:\n",
        "    if valid_classes[beat_label] == vc:\n",
        "      sum += 1\n",
        "  print(f'  {vc} - {sum}')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MCW5F6HZO8GJ"
      },
      "source": [
        "# **FFN**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wlR5g63Bpa5F"
      },
      "source": [
        "Helpful References:\n",
        "\n",
        "https://hub.packtpub.com/feedforward-networks-tensorflow/\n",
        "\n",
        "https://gist.github.com/vinhkhuc/e53a70f9e5c3f55852b0\n",
        "\n",
        "https://gist.github.com/Simsso/83fd5bf92c32d955e91ff4da4cfa48e9\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NwZARFjzA7hB"
      },
      "source": [
        "**Keras Model**\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tkisUKdtrfg0"
      },
      "source": [
        "\"\"\"\n",
        "  FNN Model\n",
        "  Libraries used:\n",
        "    -Tensorflow\n",
        "    -Keras\n",
        "  Description: the keras library makes it much easier to build a readable \n",
        "    neural network. Here we have constructed a model that takes in two\n",
        "    feature sets, merges them together, then passes through 4 dense layers\n",
        "    of decreasing sizes. Each dense layer uses the relu activation function and\n",
        "    is followed by a dropout layer. The output layer uses a signmoid activation\n",
        "    function.\n",
        "\"\"\"\n",
        "\n",
        "import tensorflow as tf\n",
        "from keras.models import Model\n",
        "from keras.layers import *\n",
        "\n",
        "# Default learning rate of the Adam optimizer is 10e-4\n",
        "learning_rate = 0.001\n",
        "num_classes = len(valid_classes)\n",
        "\n",
        "# Input Layer\n",
        "input1 = Input(x1_train.shape[1])\n",
        "input2 = Input(x2_train.shape[1])\n",
        "\n",
        "# Merge Inputs\n",
        "merged = Concatenate()([input1, input2])\n",
        "\n",
        "# Dense Layer 1\n",
        "dense1 = Dense(24, activation='relu')(merged)\n",
        "dropout1 = Dropout(rate = 0.1)(dense1)\n",
        "\n",
        "# Dense Layer 2\n",
        "dense2 = Dense(64, activation='relu')(dropout1)\n",
        "dropout2 = Dropout(rate = 0.1)(dense2)\n",
        "\n",
        "# Dense Layer 4\n",
        "dense3 = Dense(24, activation='relu')(dropout2)\n",
        "dropout3 = Dropout(rate = 0.1)(dense3)\n",
        "\n",
        "# Output Layer\n",
        "output = Dense(num_classes, activation='softmax')(dropout3)\n",
        "\n",
        "model = Model(inputs=[input1, input2], outputs=output)\n",
        "model.summary()\n",
        "\n",
        "model.compile(\n",
        "    loss = 'categorical_crossentropy', \n",
        "    optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate), \n",
        "    metrics = ['accuracy']\n",
        "  )\n",
        "\n",
        "# Print the models flow diagram\n",
        "tf.keras.utils.plot_model(model, to_file='model.png', show_shapes=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m5xd4K8mCUh6"
      },
      "source": [
        "# **Training**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IJGfS8XnhyxF"
      },
      "source": [
        "y_train = tf.keras.utils.to_categorical(y_train, num_classes)\n",
        "y_val = tf.keras.utils.to_categorical(y_val, num_classes)\n",
        "y_test = tf.keras.utils.to_categorical(y_test, num_classes)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "692BD8jsD4Cu"
      },
      "source": [
        "# Custom metrics adapted from: https://www.sabinasz.net/unbalanced-classes-machine-learning/\n",
        "# from keras import backend as K\n",
        "\n",
        "# def sensitivity(y_true, y_pred):\n",
        "#     true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n",
        "#     possible_positives = K.sum(K.round(K.clip(y_true, 0, 1)))\n",
        "#     return true_positives / (possible_positives + K.epsilon())\n",
        "\n",
        "# def specificity(y_true, y_pred):\n",
        "#     true_negatives = K.sum(K.round(K.clip((1-y_true) * (1-y_pred), 0, 1)))\n",
        "#     possible_negatives = K.sum(K.round(K.clip(1-y_true, 0, 1)))\n",
        "#     return true_negatives / (possible_negatives + K.epsilon())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nSCRzYNL7b6l"
      },
      "source": [
        "\"\"\"\n",
        "  Description: Train the FNN using the training and validation datasets \n",
        "    defined earlier. Stores relevant training history in memory for later \n",
        "    analysis.\n",
        "\n",
        "  Parameters:\n",
        "    epochs = 500\n",
        "    batch size = 100\n",
        "\"\"\"\n",
        "epochs = 250\n",
        "batch_size = 256\n",
        "\n",
        "history = model.fit([x1_train, x2_train], \n",
        "                    np.array(y_train), \n",
        "                    shuffle=True, \n",
        "                    epochs=epochs, \n",
        "                    batch_size=batch_size,\n",
        "                    validation_data = ([x1_val, x2_val], y_val))\n",
        "                    "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WK5tHRKwx7N8"
      },
      "source": [
        "# Plot training loss, validation loss\n",
        "fig, axs = plt.subplots(1,2,figsize=(16,8))\n",
        "axs[0].plot(history.history['loss'])\n",
        "axs[0].plot(history.history['val_loss'])\n",
        "axs[0].legend(['Training Loss','Validation Loss'])\n",
        "axs[0].set_title('Loss')\n",
        "axs[0].set(xlabel='Epoch', ylabel='Loss')\n",
        "\n",
        "# Plot training accuracy, validation accuracy\n",
        "axs[1].plot(history.history['accuracy'])\n",
        "axs[1].plot(history.history['val_accuracy'])\n",
        "axs[1].legend(['Training Accuracy','Validation Accuracy'])\n",
        "axs[1].set_title('Accuracy')\n",
        "axs[1].set(xlabel='Epoch', ylabel='Accuracy')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sGoimwCl05sQ"
      },
      "source": [
        "# Plot training loss\n",
        "plt.figure(0, figsize=(8, 8))\n",
        "plt.plot(history.history['loss'])\n",
        "plt.legend(['Training Loss'])\n",
        "plt.title('Loss')\n",
        "plt.xlabel('Epoch')\n",
        "plt.ylabel('Loss')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fFSdS1BpmAue"
      },
      "source": [
        "plt.figure(1, figsize=(8, 8))\n",
        "plt.plot(history.history['accuracy'])\n",
        "plt.legend(['Training Accuracy'])\n",
        "plt.title('Accuracy')\n",
        "plt.xlabel('Epoch')\n",
        "plt.ylabel('Accuracy')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_UkLubSkwu7s"
      },
      "source": [
        "# **Evaluation**\n",
        "**Determine important performance metrics of the model**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g6HzCf4S-Ybl"
      },
      "source": [
        "# Print the accuracy of the Training, Validation, and Testing datasets\n",
        "results = model.evaluate([x1_train, x2_train], y_train, verbose=0)\n",
        "print('Training Accuracy: %.2f %%'%(results[1]*100))\n",
        "results = model.evaluate([x1_val, x2_val], y_val, verbose=0)\n",
        "print('Validation Accuracy: %.2f %%'%(results[1]*100))\n",
        "results = model.evaluate([x1_test, x2_test], y_test, verbose=0)\n",
        "print('Testing Accuracy: %.2f %%'%(results[1]*100))\n",
        "print(results)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q9q3Vb--xX-v"
      },
      "source": [
        "**Confusion Matrices**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sKIbFR8-ZAks"
      },
      "source": [
        "# Print the Confusion Matrix of the Training, Validation, and Testing datasets\n",
        "from sklearn import metrics\n",
        "from sklearn.metrics import confusion_matrix\n",
        "\n",
        "# === Training Dataset ===\n",
        "y_train_actual = np.argmax(y_train, axis=1)  # Convert back from categorical array\n",
        "y_train_pred = model.predict([x1_train, x2_train])\n",
        "y_train_pred = np.argmax(y_train_pred, axis=1)\n",
        "y_train_conf_matrix = confusion_matrix(y_train_actual, y_train_pred)\n",
        "print('Training Confusion Matrix:\\n')\n",
        "print(y_train_conf_matrix)\n",
        "\n",
        "# === Validation Dataset ===\n",
        "y_val_actual = np.argmax(y_val, axis=1)  # Convert back from categorical array\n",
        "y_val_pred = model.predict([x1_val, x2_val])\n",
        "y_val_pred = np.argmax(y_val_pred, axis=1)\n",
        "y_val_conf_matrix = confusion_matrix(y_val_actual, y_val_pred)\n",
        "print('\\n\\nValidation Confusion Matrix:\\n')\n",
        "print(y_val_conf_matrix)\n",
        "\n",
        "# === Testing Dataset ===\n",
        "y_test_actual = np.argmax(y_test, axis=1)\n",
        "y_test_pred = model.predict([x1_test, x2_test])\n",
        "y_test_pred = np.argmax(y_test_pred, axis=1)\n",
        "y_test_conf_matrix = confusion_matrix(y_test_actual, y_test_pred)\n",
        "print('\\n\\nTesting Confusion Matrix:\\n')\n",
        "print(y_test_conf_matrix)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FC3oXZFN07LL"
      },
      "source": [
        "**Class Accuracy & Classification Report**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5GHRY4nX1i0h"
      },
      "source": [
        "\"\"\"\n",
        "  Description: Class-by-class method for determining accuracy. The following \n",
        "    will compute the training, validation, and testing accuracy of each beat.\n",
        "\"\"\"\n",
        "# Training\n",
        "print(\"Training Dataset Accuracies:\")\n",
        "for beat_type in range(len(valid_classes)):\n",
        "  sum_true, sum_all = 0, 0\n",
        "  for i in range(len(y_train_pred)):\n",
        "    if y_train_actual[i] == beat_type:\n",
        "      sum_all += 1 \n",
        "      if y_train_pred[i] == y_train_actual[i]:\n",
        "        sum_true += 1\n",
        "  avg = sum_true / sum_all\n",
        "  print(f' {valid_classes[beat_type]} - {avg:.4f}')\n",
        "\n",
        "# Validation\n",
        "print(\"\\nValidation Dataset Accuracies:\")\n",
        "for beat_type in range(len(valid_classes)):\n",
        "  sum_true, sum_all = 0, 0\n",
        "  for i in range(len(y_val_pred)):\n",
        "    if y_val_actual[i] == beat_type:\n",
        "      sum_all += 1 \n",
        "      if y_val_pred[i] == y_val_actual[i]:\n",
        "        sum_true += 1\n",
        "  avg = sum_true / sum_all\n",
        "  print(f' {valid_classes[beat_type]} - {avg:.4f}')\n",
        "\n",
        "# Testing\n",
        "print(\"\\nTesting Dataset Accuracies:\")\n",
        "for beat_type in range(len(valid_classes)):\n",
        "  sum_true, sum_all = 0, 0\n",
        "  for i in range(len(y_test_pred)):\n",
        "    if y_test_actual[i] == beat_type:\n",
        "      sum_all += 1 \n",
        "      if y_test_pred[i] == y_test_actual[i]:\n",
        "        sum_true += 1\n",
        "  avg = sum_true / sum_all\n",
        "  print(f' {valid_classes[beat_type]} - {avg:.4f}')\n",
        "\n",
        "\n",
        "# def per_class_accuracy(y_preds,y_true,class_labels):\n",
        "#     return [np.mean([\n",
        "#         (y_true[pred_idx] == np.round(y_pred)) for pred_idx, y_pred in enumerate(y_preds) \n",
        "#       if y_true[pred_idx] == int(class_label)\n",
        "#                     ]) for class_label in class_labels]\n",
        "\n",
        "# def update_val_history():\n",
        "#     [val_history[class_label].append(np.mean( np.asarray(temp_history).T[class_idx] )\n",
        "#                              ) for class_idx, class_label in enumerate(class_labels)]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gaEkCget3zyq"
      },
      "source": [
        "\"\"\"\n",
        "  Description: Class-by-class method for determining specificity. The following \n",
        "    will compute the training, validation, and testing specificity of each beat.\n",
        "\"\"\"\n",
        "\n",
        "# Training\n",
        "print(\"Training Dataset Specificities:\")\n",
        "for beat_type in range(len(valid_classes)):\n",
        "  row = y_train_conf_matrix[beat_type]\n",
        "  col = y_train_conf_matrix[:,beat_type]\n",
        "  FP = np.sum(row[:beat_type]) + np.sum(row[beat_type+1:])\n",
        "  TN = len(y_train) - np.sum(col) - FP\n",
        "  specificity = TN / (TN+FP)\n",
        "  print(f' {valid_classes[beat_type]} - {specificity:.4f}')\n",
        "\n",
        "# Validation\n",
        "print(\"\\nValidation Dataset Specificities:\")\n",
        "for beat_type in range(len(valid_classes)):\n",
        "  row = y_val_conf_matrix[beat_type]\n",
        "  col = y_val_conf_matrix[:,beat_type]\n",
        "  FP = np.sum(row[:beat_type]) + np.sum(row[beat_type+1:])\n",
        "  TN = len(y_val) - np.sum(col) - FP\n",
        "  specificity = TN / (TN+FP)\n",
        "  print(f' {valid_classes[beat_type]} - {specificity:.4f}')\n",
        "\n",
        "# Testing\n",
        "print(\"\\nTesting Dataset Specificities:\")\n",
        "for beat_type in range(len(valid_classes)):\n",
        "  row = y_test_conf_matrix[beat_type]\n",
        "  col = y_test_conf_matrix[:,beat_type]\n",
        "  FP = np.sum(row[:beat_type]) + np.sum(row[beat_type+1:])\n",
        "  TN = len(y_test) - np.sum(col) - FP\n",
        "  specificity = TN / (TN+FP)\n",
        "  print(f' {valid_classes[beat_type]} - {specificity:.4f}')\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yPiaawZfizon"
      },
      "source": [
        "# Print a classification report for the Training, Validation, and Testing datasets\n",
        "from sklearn.metrics import classification_report\n",
        "\n",
        "# y_pred_train_bool = np.argmax(y_pred, axis=1)\n",
        "print(\"\\n\\n\\t\\t\\t===| Training |===\\n\")\n",
        "print(classification_report(y_train_actual, y_train_pred, \n",
        "                            target_names=valid_classes, digits=4))\n",
        "\n",
        "# y_val_pred_bool = np.argmax(y_pred, axis=1)\n",
        "print(\"\\n\\n\\t\\t\\t===| Validation |===\\n\")\n",
        "print(classification_report(y_val_actual, y_val_pred, \n",
        "                            target_names=valid_classes, digits=4))\n",
        "\n",
        "# y_test_pred_bool = np.argmax(y_pred, axis=1)\n",
        "print(\"\\n\\n\\t\\t\\t===| TESTING |===\\n\")\n",
        "print(classification_report(y_test_actual, y_test_pred, \n",
        "                            target_names=valid_classes, digits=4))"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}