BCI_Workshop_2023.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fd4Q-9BRo_Wx"
      },
      "source": [
        "## **Workshop on how to Bridge the gap between Neuroscience & Computational Intelligence for BCI**\n",
        "## See more detail about workshop here: thinknew.github.io/BCIWorkshop2023/\n",
        "\n",
        "### Purpose\n",
        "**This notebook aims to demonstrate and teach the following content:**\n",
        "\n",
        "* Demonstrate the importance standardised preprocessing pipeline\n",
        "* Highlight the typical problems encountered during biosignal timeseries classification\n",
        "* Develop and tune your own deep learning classification pipeline"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e0NnWLMu6H9o"
      },
      "source": [
        "# Setting Up the Environment"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fKG1xTbJpOsJ"
      },
      "source": [
        "The prerequisite packages to this tutorial are:\n",
        "\n",
        "\n",
        "*   [**MNE**](https://mne.tools/stable/install/mne_python.html#installing-mne-python-and-its-dependencies): EEG Data Package\n",
        "*   [**NumPy**](https://www.scipy.org/install.html): Numerical Computing (SciPy Download Page)\n",
        "*   [**EinOps**](https://einops.rocks/): Tensor operations using Einstein Notation (Einops Documentation Page)\n",
        "*   [**SciPy**](https://www.scipy.org/install.html): Scientific Computing\n",
        "*   [**MatPlotLib**](https://matplotlib.org/users/installing.html): General Purpose Machine Learning Library\n",
        "*   [**Scikit-Learn**](https://scikit-learn.org/stable/install.html): General Purpose Machine Learning Library\n",
        "*   [**Tensorflow 2.0**](https://www.tensorflow.org/guide/effective_tf2/): Deep Learning Library from Google Brain\n",
        "\n",
        "All packages but MNE are available through Google Colab and thus we only need to install MNE."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kexrc29EpW4h",
        "outputId": "c1038c8e-03e8-4632-a485-8f03b3d6a163"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Requirement already satisfied: mne in /usr/local/lib/python3.10/dist-packages (1.4.2)\n",
            "Requirement already satisfied: numpy>=1.15.4 in /usr/local/lib/python3.10/dist-packages (from mne) (1.22.4)\n",
            "Requirement already satisfied: scipy>=1.6.3 in /usr/local/lib/python3.10/dist-packages (from mne) (1.10.1)\n",
            "Requirement already satisfied: matplotlib>=3.4.0 in /usr/local/lib/python3.10/dist-packages (from mne) (3.7.1)\n",
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from mne) (4.65.0)\n",
            "Requirement already satisfied: pooch>=1.5 in /usr/local/lib/python3.10/dist-packages (from mne) (1.6.0)\n",
            "Requirement already satisfied: decorator in /usr/local/lib/python3.10/dist-packages (from mne) (4.4.2)\n",
            "Requirement already satisfied: packaging in /usr/local/lib/python3.10/dist-packages (from mne) (23.1)\n",
            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from mne) (3.1.2)\n",
            "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.4.0->mne) (1.1.0)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.4.0->mne) (0.11.0)\n",
            "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.4.0->mne) (4.40.0)\n",
            "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.4.0->mne) (1.4.4)\n",
            "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.4.0->mne) (8.4.0)\n",
            "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.4.0->mne) (3.1.0)\n",
            "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.4.0->mne) (2.8.2)\n",
            "Requirement already satisfied: appdirs>=1.3.0 in /usr/local/lib/python3.10/dist-packages (from pooch>=1.5->mne) (1.4.4)\n",
            "Requirement already satisfied: requests>=2.19.0 in /usr/local/lib/python3.10/dist-packages (from pooch>=1.5->mne) (2.27.1)\n",
            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->mne) (2.1.3)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.7->matplotlib>=3.4.0->mne) (1.16.0)\n",
            "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests>=2.19.0->pooch>=1.5->mne) (1.26.16)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests>=2.19.0->pooch>=1.5->mne) (2023.5.7)\n",
            "Requirement already satisfied: charset-normalizer~=2.0.0 in /usr/local/lib/python3.10/dist-packages (from requests>=2.19.0->pooch>=1.5->mne) (2.0.12)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests>=2.19.0->pooch>=1.5->mne) (3.4)\n",
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Requirement already satisfied: tensorboardX in /usr/local/lib/python3.10/dist-packages (2.6.1)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from tensorboardX) (1.22.4)\n",
            "Requirement already satisfied: packaging in /usr/local/lib/python3.10/dist-packages (from tensorboardX) (23.1)\n",
            "Requirement already satisfied: protobuf>=4.22.3 in /usr/local/lib/python3.10/dist-packages (from tensorboardX) (4.23.3)\n",
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Requirement already satisfied: einops in /usr/local/lib/python3.10/dist-packages (0.6.1)\n"
          ]
        }
      ],
      "source": [
        "# Run these from the console if following along locally\n",
        "!pip install mne\n",
        "!pip install tensorboardX\n",
        "!pip install einops"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kDOyVajGpe16"
      },
      "source": [
        "For the purposes of this workshop, we will be turning off warnings."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "4hwinWF8phEz"
      },
      "outputs": [],
      "source": [
        "# You'll want to comment this out if you plan on modifying this code, to get valuable feedback\n",
        "import warnings\n",
        "warnings.filterwarnings('ignore')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9gw-oUX9pm1D"
      },
      "source": [
        "Import all of our required modules. This includes various submodules that we'll need including the RobustScaler object from scikit."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "KXBBdX-Mot9N"
      },
      "outputs": [],
      "source": [
        "from collections import OrderedDict\n",
        "from pylab import rcParams\n",
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "from tensorflow.keras import layers\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib as mpl\n",
        "from matplotlib.cm import get_cmap\n",
        "import numpy as np\n",
        "import mne\n",
        "from scipy.io import loadmat\n",
        "import sklearn\n",
        "from sklearn.preprocessing import RobustScaler\n",
        "from sklearn.preprocessing import MinMaxScaler\n",
        "import h5py\n",
        "import json\n",
        "\n",
        "from einops import rearrange\n",
        "\n",
        "from google.colab import drive, files"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def make_labels(data, is_target:bool=False):\n",
        "  data_len = data.shape[-1]\n",
        "  if is_target:\n",
        "    labels = np.ones((data_len, 1), dtype=bool)\n",
        "  else:\n",
        "    labels = np.zeros((data_len, 1), dtype=bool)\n",
        "  return labels"
      ],
      "metadata": {
        "id": "3kR-j3KSSvue"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def append_true_false_set(true_set, false_set):\n",
        "  # assume shape is (n_trials, time_steps, n_channels)\n",
        "  true_data, true_labels = true_set\n",
        "  false_data, false_labels = false_set\n",
        "\n",
        "  data_set = np.concatenate((true_data, false_data), axis=-1)\n",
        "  label_set = np.concatenate((true_labels, false_labels), axis=0)\n",
        "  return data_set, label_set"
      ],
      "metadata": {
        "id": "99i4pnaRcVGn"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def shuffle_dset(data_set, label_set):\n",
        "  N_d = data_set.shape[-1]\n",
        "  N_l = len(label_set)\n",
        "  print(data_set.shape)\n",
        "  print(label_set.shape)\n",
        "  assert N_d==N_l, \\\n",
        "  \"Incorrect labelling for data length: {data_set}\"\n",
        "  p = np.random.permutation(N_d)\n",
        "  return data_set[...,p], label_set[p]"
      ],
      "metadata": {
        "id": "1xL_oQavdNv6"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "iMPxNpHFHj3q"
      },
      "outputs": [],
      "source": [
        "# Do not need to worry about this, just a function to extract the relevant data\n",
        "# from the preprocessing files\n",
        "def get_data_and_labels(selected_json, is_target:bool=False):\n",
        "  keys = selected_json.keys()\n",
        "  data_key = [k for k in keys if 'data' in k.lower()].pop()\n",
        "  data = selected_json[data_key]\n",
        "  data = np.array(data)\n",
        "  labels = make_labels(data, is_target=is_target)\n",
        "\n",
        "  return data, labels"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "97yl86kf6xdv"
      },
      "source": [
        "## Reproducibility Matters\n",
        "When conducting experiments on any given dataset, we want to make sure our changes implemented in the code are caused by said changes, and not a fortunate (or unfortunate) sequence of random operations."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "QWUujYPKrCrP"
      },
      "outputs": [],
      "source": [
        "# Set seed to reproduce behaviour\n",
        "tf.random.set_seed(100)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HV2Z8Olztskd"
      },
      "source": [
        "# Data Analysis\n",
        "In this section we will load, view, and process our data to prepare it for training and testing."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0hOpX20IukZA"
      },
      "source": [
        "## Load the EEG data\n",
        "Here we will load both the raw and preprocessed data."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 38
        },
        "id": "ps2BMs05tkSv",
        "outputId": "27446c0a-53de-4601-e29b-ec3edd4a3fcf"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-356de857-28da-4b8c-9391-7a49e2e9a18e\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-356de857-28da-4b8c-9391-7a49e2e9a18e\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        }
      ],
      "source": [
        "uploaded = files.upload()\n",
        "\n",
        "for fn in uploaded.keys():\n",
        "  print('User uploaded file \"{name}\" with length {length} bytes'.format(\n",
        "      name=fn, length=len(uploaded[fn])))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "QPAAAGmtRmL8"
      },
      "outputs": [],
      "source": [
        "# Specify the name of your file to load from\n",
        "target_data = './Target_Data.json'\n",
        "nontarget_data = './NonTarget_Data.json'"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "with open(target_data, 'r') as f:\n",
        "  target_json = json.load(f)\n",
        "print(\"Here are the keys: \", target_json.keys())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "x0Dsoe7FUgAI",
        "outputId": "c18f7714-6baf-44f4-ec4b-564c67803bfe"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Here are the keys:  dict_keys(['srate', 'ChannelLabels', 'Data'])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "with open(nontarget_data, 'r') as f:\n",
        "  nontarget_json = json.load(f)\n",
        "print(\"Here are the keys: \", nontarget_json.keys())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wMHsGEfVU0-J",
        "outputId": "5571c13f-8ed1-43f2-d38d-007b222fe4e6"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Here are the keys:  dict_keys(['srate', 'ChannelLabels', 'Data'])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "channel_names = target_json['ChannelLabels']"
      ],
      "metadata": {
        "id": "UTU3Mu11lqxV"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "target_data, target_labels = get_data_and_labels(target_json, is_target=True)\n",
        "nontarget_data, nontarget_labels = get_data_and_labels(nontarget_json, is_target=False)"
      ],
      "metadata": {
        "id": "lVjnk6TugKim"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Verify that the data shape is what we expect.\n",
        "# We should see [n_channels, window_size, n_trials]\n",
        "print(\"---------\\nTarget Data\\n---------\")\n",
        "print(target_data.shape)\n",
        "print(target_labels.shape)\n",
        "print(\"---------\\nNon-Target Data\\n---------\")\n",
        "print(nontarget_data.shape)\n",
        "print(nontarget_labels.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SRDltyyAk5Cl",
        "outputId": "a2773a38-203d-48c2-9f60-7683ae008afe"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "---------\n",
            "Target Data\n",
            "---------\n",
            "(63, 384, 130)\n",
            "(130, 1)\n",
            "---------\n",
            "Non-Target Data\n",
            "---------\n",
            "(63, 384, 390)\n",
            "(390, 1)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "data, labels = append_true_false_set((target_data, target_labels),\n",
        "                                     (nontarget_data, nontarget_labels))\n",
        "data, labels = shuffle_dset(data, labels)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2Willil1g5RG",
        "outputId": "b4f2b6bd-c156-4b59-ab31-57c6f1c388d1"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(63, 384, 520)\n",
            "(520, 1)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "id": "ZqPGTvbwHoM7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "969e11c6-394b-4f29-a930-d4cb66767689"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[False  True False  True False  True False False False False False  True\n",
            "  True False  True False False  True False  True False False  True False\n",
            "  True False]\n"
          ]
        }
      ],
      "source": [
        "# Verify that our labels are properly shuffled by printing every n-th label\n",
        "n = 20\n",
        "print(labels[::n].flatten())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vueQZqLErkGW"
      },
      "source": [
        "This kind of data format is less intuitive to understand if we are used to seeing channel information in the last dimension, and 'batched' or 'epoched' information in the first dimension. Let's rearrange this to avoid any confusion later on."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "id": "CwcyDv4Nr90v"
      },
      "outputs": [],
      "source": [
        "def rearrange_to_bnc(data):\n",
        "  # TODO: Currently the data shape is (n_channels, time_steps, n_trials)\n",
        "  # Rearrange the data format to match the notation\n",
        "  # (n_trials, time_steps, n_channels).\n",
        "  pass"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dCD2QVd73xt7"
      },
      "source": [
        "Let's check that we have set everything up correctly by visually comparing the raw and processed data for a select channel.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "id": "23kmnv7esSP7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "803090da-a88e-4096-9b39-7d89320ab315"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(520, 384, 63)\n"
          ]
        }
      ],
      "source": [
        "data = rearrange_to_bnc(data)\n",
        "print(data.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "id": "cwqQ0AKcqHoF"
      },
      "outputs": [],
      "source": [
        "ch_to_plot = 0 # select a valid channel for plotting, (max 4)\n",
        "scaler = 1e-4 # change for larger or small separation between singular plots\n",
        "color = 'tab:blue' # change for different colours"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "id": "TDCAWzPFuKx1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "64c6b498-9827-4ef3-e563-0243b3d96942"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(520, 384, 63)\n"
          ]
        }
      ],
      "source": [
        "# Plot\n",
        "print(data.shape)\n",
        "channel = channel_names[ch_to_plot]\n",
        "data_ch = data[..., ch_to_plot]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "id": "rLgpcHDLpyJY",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 622
        },
        "outputId": "e6bf0eb4-7aee-49eb-e55e-dd290000026c"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1500x700 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "rcParams['figure.figsize'] = 15, 7\n",
        "plt.figure(1)\n",
        "plt.title(channel+'-processed')\n",
        "for j, p_data in enumerate(data_ch):\n",
        "  p_data += j*scaler\n",
        "  plt.plot(p_data, color=color)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cjq3Gnb-u1Jb"
      },
      "source": [
        "# Data Preparation\n",
        "We need to scale and split our data to feed into our model for training."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D5xBDwTztqpD"
      },
      "source": [
        "Let's choose what channels we want to train our neural network with.\n",
        "\n",
        "*Note: the P300 signal is a visually stimulated biomarker, expressed in the occipital lobe.*"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "id": "p6gi40dDuymy"
      },
      "outputs": [],
      "source": [
        "# Choose what channels we want to select to train on.\n",
        "channels_to_train = [0,1] # Select multiple with a list: [0, 1, 2]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "id": "hlWbUhYS4y9K"
      },
      "outputs": [],
      "source": [
        "P300_data_c = data[..., channels_to_train]\n",
        "P300_label = labels"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bnYmbZ9VyZGy"
      },
      "source": [
        "## Split Training and Testing Data\n",
        "Now that we have selected our data for training, we need to setup our training and testing dataset.\n",
        "<a title=\"Kaaiian, CC BY-SA 4.0 &lt;https://creativecommons.org/licenses/by-sa/4.0&gt;, via Wikimedia Commons\" href=\"https://commons.wikimedia.org/wiki/File:Train-Test-Validation.png\"><img width=\"512\" alt=\"Train-Test-Validation\" src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/1/12/Train-Test-Validation.png/512px-Train-Test-Validation.png\"></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {
        "id": "6l3Y1Xifu8bd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0d211a61-e060-4b92-ffd8-ac8a8eb24cad"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(416, 384, 2)\n",
            "(104, 384, 2)\n"
          ]
        }
      ],
      "source": [
        "from sklearn.model_selection import train_test_split\n",
        "P300_data_c_train, P300_data_c_test, P300_label_c_train, P300_label_c_test = \\\n",
        "    train_test_split(P300_data_c, P300_label, test_size=0.2, random_state=123)\n",
        "\n",
        "print(P300_data_c_train.shape)\n",
        "print(P300_data_c_test.shape)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_WbQmZP1yo2F"
      },
      "source": [
        "Normalisation is an important step to help reduce bias in our data and ensure the model weighs each channel as evenly as possible.\n",
        "\n",
        "Let's normalize our data over each channel to fit between 0 and 1 (i.e. for each channel, all the values are between 0 and 1)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {
        "id": "Y0KByhUAcQpI"
      },
      "outputs": [],
      "source": [
        "# MinMax Normalisation function\n",
        "# TODO: Is a way to linearise this calculation and speed it up?\n",
        "def normalise(data):\n",
        "  n_channels = data.shape[-1]\n",
        "  for c in range(n_channels):\n",
        "    data_to_scale = data[..., c]\n",
        "    scaler = MinMaxScaler()\n",
        "    data[..., c] = scaler.fit_transform(data_to_scale)\n",
        "  return data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "id": "ktsq6-6hdxJ3"
      },
      "outputs": [],
      "source": [
        "P300_data_c_train = normalise(P300_data_c_train)\n",
        "P300_data_c_test = normalise(P300_data_c_test)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BX3fGjDCuL9u"
      },
      "source": [
        "# Neural Network\n",
        "\n",
        "\n",
        "<a href=\"https://www.researchgate.net/figure/Multi-layer-perceptron-MLP-NN-basic-Architecture_fig2_354817375\"><img src=\"https://www.researchgate.net/publication/354817375/figure/fig2/AS:1071622807097344@1632506195651/Multi-layer-perceptron-MLP-NN-basic-Architecture.jpg\" alt=\"Multi-layer perceptron (MLP-NN) basic Architecture.\"/></a>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M6GSnoZtrfAk"
      },
      "source": [
        "Initialize parameters including EEG related Metadata.\n",
        "\n",
        "\n",
        "*   **eeg_sample_count**:  Number of samples we're training our network with\n",
        "*   **learning_rate**:     How fast the network tends to change its weights\n",
        "*   **loss**:              Function for evaluating our model against the dataset\n",
        "*   **batch_size**:        Batching the dataset for training\n",
        "*   **eeg_sample_length**: Number of datapoints per sample\n",
        "*   **number_of_classes**: Number of output classes (a scalar value that represents probability of input belonging to p300)\n",
        "*   **hidden1**: Number of neurons in the first hidden layer\n",
        "*   **hidden2**: Number of neurons in the second hidden layer\n",
        "*   **hidden3**: Number of neurons in the third hidden layer\n",
        "*   **output**: Number of neurons in the output layer"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {
        "id": "PZgYCnwDrime"
      },
      "outputs": [],
      "source": [
        "# Initialize parameters\n",
        "eeg_sample_count = 240 # How many samples are we training\n",
        "epochs = 10 # number of times we loop through our training data\n",
        "learning_rate = 1e-3 # How hard the network will correct its mistakes while learning\n",
        "loss = 'mse' # Metric for our optimizer to minimise\n",
        "batch_size = 32 # Number of samples in our batch\n",
        "eeg_sample_length = 226 # Number of eeg data points per sample\n",
        "number_of_classes = 1 # We want to answer the \"is this a P300?\" question\n",
        "hidden1 = 500 # Number of neurons in our first hidden layer\n",
        "hidden2 = 1000 # Number of neurons in our second hidden layer\n",
        "hidden3 = 100 # Number of neurons in our third hidden layer\n",
        "penultimate = 10 # Number of neurons in our output layer\n",
        "metrics = ['binary_accuracy'] # Metrics for us to monitor during training and tuning"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J1uNnjuBOH_h"
      },
      "source": [
        "We use our hyperparameters to define our neural network model."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {
        "id": "Rli0wVvtOHQM"
      },
      "outputs": [],
      "source": [
        "## Define the network\n",
        "P300_model = keras.Sequential()\n",
        "\n",
        "# Input Layer (Size 226 -> 500)\n",
        "P300_model.add(layers.Dense(hidden1, activation=\"relu\", name=\"Input_Layer\"))\n",
        "\n",
        "# Hidden Layer (Size 500 -> 1000)\n",
        "P300_model.add(layers.Dense(hidden2, activation=\"relu\", name=\"Hidden_Layer1\"))\n",
        "\n",
        "# Hidden Layer (Size 1000 -> 100)\n",
        "P300_model.add(layers.Dense(hidden3, activation=\"relu\", name=\"Hidden_Layer2\"))\n",
        "\n",
        "# Hidden Layer (Size 100 -> 10)\n",
        "P300_model.add(layers.Dense(penultimate, activation=\"relu\", name=\"Hidden_Layer3\"))\n",
        "\n",
        "# Handle multi-channel inputs.\n",
        "P300_model.add(layers.Flatten())\n",
        "\n",
        "# Output Layer (Size 10 -> 1)\n",
        "P300_model.add(layers.Dense(number_of_classes, activation=\"sigmoid\", name=\"Output_Layer\"))\n",
        "\n",
        "# Define a learning function, needs to be reinitialized every load\n",
        "optimizer = keras.optimizers.Adam(learning_rate)\n",
        "# After the model is created, we then config the model with losses and metrics\n",
        "P300_model.compile(optimizer=optimizer,\n",
        "             loss=loss,\n",
        "             metrics=metrics)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CJ4zMnYJOpkl"
      },
      "source": [
        "## Training and Testing\n",
        "Now that we have our model defined, we can train and test on our dataset.\n",
        "<a title=\"Роман Сузи, CC BY-SA 3.0 &lt;https://creativecommons.org/licenses/by-sa/3.0&gt;, via Wikimedia Commons\" href=\"https://commons.wikimedia.org/wiki/File:Gradient_descent_method.png\"><img width=\"512\" alt=\"Gradient descent method\" src=\"https://upload.wikimedia.org/wikipedia/commons/5/5b/Gradient_descent_method.png\"></a>\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {
        "id": "lijhJnEWO0Sf",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 832
        },
        "outputId": "c2d89b4d-bdcd-45f4-de7e-fbca72572fac"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/10\n",
            "13/13 [==============================] - 14s 868ms/step - loss: 0.2139 - binary_accuracy: 0.6851\n",
            "Epoch 2/10\n",
            "13/13 [==============================] - 19s 1s/step - loss: 0.1967 - binary_accuracy: 0.7332\n",
            "Epoch 3/10\n",
            "13/13 [==============================] - 17s 1s/step - loss: 0.1990 - binary_accuracy: 0.7332\n",
            "Epoch 4/10\n",
            "13/13 [==============================] - 12s 957ms/step - loss: 0.2002 - binary_accuracy: 0.7332\n",
            "Epoch 5/10\n",
            "13/13 [==============================] - 12s 956ms/step - loss: 0.1958 - binary_accuracy: 0.7332\n",
            "Epoch 6/10\n",
            "13/13 [==============================] - 12s 936ms/step - loss: 0.1989 - binary_accuracy: 0.7332\n",
            "Epoch 7/10\n",
            "13/13 [==============================] - 11s 840ms/step - loss: 0.1967 - binary_accuracy: 0.7332\n",
            "Epoch 8/10\n",
            "13/13 [==============================] - 12s 900ms/step - loss: 0.1977 - binary_accuracy: 0.7332\n",
            "Epoch 9/10\n",
            "13/13 [==============================] - 12s 967ms/step - loss: 0.1972 - binary_accuracy: 0.7332\n",
            "Epoch 10/10\n",
            "13/13 [==============================] - 13s 1s/step - loss: 0.1965 - binary_accuracy: 0.7332\n",
            "Below is the loss graph for dataset training session\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x500 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "# Make sure we're starting from untrained every time\n",
        "#tutorial_model = keras.models.load_model('/home/tutorial_model_default_state')\n",
        "#tf.compat.v1.initializers.global_variables()\n",
        "mse_list = P300_model.fit(P300_data_c_train, P300_label_c_train, batch_size=batch_size,\n",
        "                          epochs=epochs, verbose=1)\n",
        "\n",
        "# Define a learning function, needs to be reinitialized every load\n",
        "# optimizer = torch.optim.Adam(tutorial_model.parameters(), lr = learning_rate)\n",
        "\n",
        "# Use our training procedure with the sample data\n",
        "print(\"Below is the loss graph for dataset training session\")\n",
        "loss_data = mse_list.history['loss']\n",
        "# Plot a nice loss graph at the end of training\n",
        "rcParams['figure.figsize'] = 10, 5\n",
        "plt.title(\"Loss vs Iterations\")\n",
        "plt.plot(list(range(0, len(loss_data))), loss_data)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Om7B513hPHV0"
      },
      "source": [
        "## Classification Performance"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {
        "id": "8iEza5qZPLOO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7f2b2cdf-6302-4dcd-d0a5-eaa973f5d78f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4/4 [==============================] - 1s 209ms/step\n",
            "classification max:  0.0\n",
            "(104, 1)\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "       False       0.82      1.00      0.90        85\n",
            "        True       0.00      0.00      0.00        19\n",
            "\n",
            "    accuracy                           0.82       104\n",
            "   macro avg       0.41      0.50      0.45       104\n",
            "weighted avg       0.67      0.82      0.74       104\n",
            "\n"
          ]
        }
      ],
      "source": [
        "# Classify our positive test dataset and print the results\n",
        "classification_test = np.round(P300_model.predict(P300_data_c_test))\n",
        "print(\"classification max: \", classification_test.max())\n",
        "print(classification_test.shape)\n",
        "from sklearn.metrics import classification_report\n",
        "print(classification_report(P300_label_c_test, classification_test))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2t7dk9VdPYPR"
      },
      "source": [
        "# Review\n",
        "How did your model do? How did your model do with you data after signal processing? What hyperparameters significantly affected the performance?"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "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.8.6"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}