[LECTURE]kohi2022_eeg_mac.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Yy0WHpW3X9oX"
      },
      "source": [
        "# Prediction of anesthetic concentration from EEG\n",
        "In this example, we will build a model to predict anesthetic concentration (age-related MAC) from EEG during Sevoflurane anesthesia.\n",
        "\n",
        "> Note that <b>all users who use Vital DB, an open biosignal dataset, must agree to the Data Use Agreement below. \n",
        "</b> If you do not agree, please close this window. \n",
        "Click here: [Data Use Agreement](https://vitaldb.net/dataset/?query=overview&documentId=13qqajnNZzkN7NZ9aXnaQ-47NWy7kx-a6gbrcEsi-gak&sectionId=h.vcpgs1yemdb5)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9SwIjOX9frk6"
      },
      "source": [
        "## Required libraries"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Ch6czkFZfw_G"
      },
      "outputs": [],
      "source": [
        "!pip install vitaldb\n",
        "\n",
        "import vitaldb\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import os\n",
        "import scipy.signal\n",
        "import matplotlib.pyplot as plt\n",
        "import random\n",
        "import itertools as it\n",
        "import numpy as np"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Set random seed\n",
        "\n",
        "SEED = 42\n",
        "random.seed(SEED)\n",
        "np.random.seed(SEED)"
      ],
      "metadata": {
        "id": "o338Uisi_Lpw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZjxFdZTXBZWb"
      },
      "source": [
        "## Preprocessing"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AabTJc6dflSy"
      },
      "source": [
        "Load data using <code>VitalDB Web API</code>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "df_trks = pd.read_csv(\"https://api.vitaldb.net/trks\")  # track information\n",
        "df_cases = pd.read_csv(\"https://api.vitaldb.net/cases\")  # patient information\n",
        "\n",
        "# Inclusion & Exclusion criteria\n",
        "######### TODO 1 #########\n",
        "# 나이 18세 초과이면서, 아래 3개의 데이터트랙(tname)을 가진 caseid를 caseids라는 목록으로 만듧니다.\n",
        "# 1) 'BIS/EEG1_WAV', 2) 'BIS/BIS', 3) 'Primus/EXP_SEVO'\n",
        "\n",
        "#### INSERT CODE ####\n",
        "\n",
        "len(caseids) # The output should be 3300"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BQ5rRXjYlqnk",
        "outputId": "fd9845dc-b87c-4efa-8a36-aaee5e8e9386"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3300"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0b_TyfelWg6e"
      },
      "outputs": [],
      "source": [
        "SRATE = 128  # in hz\n",
        "SEGLEN = 4 * SRATE  # samples\n",
        "MAX_CASES = 50 #100\n",
        "\n",
        "# Column order when loading data\n",
        "EEG = 0\n",
        "SEVO = 1\n",
        "BIS = 2\n",
        "\n",
        "x = []  \n",
        "y = []  # sevo\n",
        "b = []  # bis\n",
        "c = []  # caseids\n",
        "icase = 0  # number of loaded cases\n",
        "for caseid in caseids:\n",
        "    print('loading {} ({}/{})'.format(caseid, icase, MAX_CASES), end='...', flush=True)\n",
        "\n",
        "    # Excluding the following values\n",
        "    if np.any(vitaldb.load_case(caseid, 'Orchestra/PPF20_CE') > 0.2):\n",
        "        print('propofol')\n",
        "        continue\n",
        "    if np.any(vitaldb.load_case(caseid, 'Primus/EXP_DES') > 1):\n",
        "        print('desflurane')\n",
        "        continue\n",
        "    if np.any(vitaldb.load_case(caseid, 'Primus/FEN2O') > 2):\n",
        "        print('n2o')\n",
        "        continue\n",
        "    if np.any(vitaldb.load_case(caseid, 'Orchestra/RFTN50_CE') > 0.2):\n",
        "        print('remifentanil')\n",
        "        continue\n",
        "\n",
        "    # Extract data\n",
        "    vals = vitaldb.load_case(caseid, ['BIS/EEG1_WAV', 'Primus/EXP_SEVO', 'BIS/BIS'], 1 / SRATE)\n",
        "    if np.nanmax(vals[:, SEVO]) < 1:\n",
        "        print('all sevo <= 1')\n",
        "        continue\n",
        "\n",
        "    # Convert etsevo to the age related mac\n",
        "    age = df_cases.loc[df_cases['caseid'] == caseid, 'age'].values[0]\n",
        "    vals[:, SEVO] /= 1.80 * 10 ** (-0.00269 * (age - 40))\n",
        "\n",
        "    if not np.any(vals[:, BIS] > 0):\n",
        "        print('all bis <= 0')\n",
        "        continue\n",
        "\n",
        "    # Since the EEG should come out well, we start from the location where the value of bis was first calculated.\n",
        "    valid_bis_idx = np.where(vals[:, BIS] > 0)[0]\n",
        "    first_bis_idx = valid_bis_idx[0]\n",
        "    last_bis_idx = valid_bis_idx[-1]\n",
        "    vals = vals[first_bis_idx:last_bis_idx + 1, :]\n",
        "\n",
        "    if len(vals) < 1800 * SRATE:  # Do not use cases that are less than 30 minutes\n",
        "        print('{} len < 30 min'.format(caseid))\n",
        "        continue\n",
        "\n",
        "    # Forward fill in MAC value and BIS value up to 5 seconds\n",
        "    vals[:, SEVO:] = pd.DataFrame(vals[:, SEVO:]).ffill(limit=5 * SRATE).values\n",
        "\n",
        "    # Extract data every 1 second from its start to its end and then put into the dataset\n",
        "    oldlen = len(y)\n",
        "    for irow in range(SEGLEN, len(vals), SRATE):\n",
        "        bis = vals[irow, BIS]\n",
        "        mac = vals[irow, SEVO]\n",
        "        if np.isnan(bis) or np.isnan(mac) or bis == 0:\n",
        "            continue\n",
        "        # add dataset\n",
        "        eeg = vals[irow - SEGLEN:irow, EEG]\n",
        "        x.append(eeg)\n",
        "        y.append(mac)\n",
        "        b.append(bis)\n",
        "        c.append(caseid)\n",
        "\n",
        "    # Valid case\n",
        "    icase += 1\n",
        "    print('{} samples read -> total {} samples ({}/{})'.format(len(y) - oldlen, len(y), icase, MAX_CASES))\n",
        "    if icase >= MAX_CASES:\n",
        "        break\n",
        "\n",
        "# Change the input dataset to a numpy array\n",
        "x_raw = np.array(x)\n",
        "y_raw = np.array(y)\n",
        "b_raw = np.array(b)\n",
        "c_raw = np.array(c)\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        " ######### TODO 2 #########\n",
        "def invalid(x, y, b, c, imp_range = 12):\n",
        "    ######### TODO 2 : Step 1 #########\n",
        "    print('invalid samples...', end='', flush=True)\n",
        "    valid_mask = #### INSERT CODE #### # 결측치가 하나라도 있는 egg sample을 제거\n",
        "    valid_mask &= #### INSERT CODE ####  # eeg의 전체 range가 12 미만이면 제거 (임피던스 체크)\n",
        "    x = x[valid_mask, :]\n",
        "    y = y[valid_mask]\n",
        "    b = b[valid_mask]\n",
        "    c = c[valid_mask]\n",
        "    print('{:.1f}% removed'.format(100*(1-np.mean(valid_mask))))\n",
        "    return x, y, b, c\n",
        "\n",
        "def drift(x, window=91, order=3):\n",
        "    ######### TODO 2 : Step 2 #########\n",
        "    print('baseline drift...', end='', flush=True)\n",
        "    #### INSERT CODE ####     # remove baseline drift using Savitzky Golay Filtering (Recommend library: Scipy)\n",
        "    print('removed')\n",
        "    return x\n",
        "\n",
        "def noise(x, y, b, c, upper_thres=100):\n",
        "     ######### TODO 2 : Step 3 #########\n",
        "    print('noisy samples...', end='', flush=True)\n",
        "    valid_mask = #### INSERT CODE ####    # Remove if the value of noise is bigger than 100\n",
        "    x = x[valid_mask, :]  # To use CNN, it should be three-dimensional. Therefore, add the dimension.\n",
        "    y = y[valid_mask]\n",
        "    b = b[valid_mask]\n",
        "    c = c[valid_mask]\n",
        "    print('{:.1f}% removed'.format(100*(1-np.mean(valid_mask))))\n",
        "    return x, y, b, c\n"
      ],
      "metadata": {
        "id": "4JUkhAAHfQYc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NwwLDouezDLc"
      },
      "source": [
        "## Filtering input data"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#1 remove missing values\n",
        "x, y, b, c = invalid(x_raw, y_raw, b_raw, c_raw)\n",
        "\n",
        "#2 remove baseline drift\n",
        "x = drift(x)\n",
        "\n",
        "#3 remove noise bigger than 100\n",
        "x, y, b, c = noise(x, y, b, c)"
      ],
      "metadata": {
        "id": "NIBFlnr6fMuF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x.shape"
      ],
      "metadata": {
        "id": "eIY72uviLLcL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "samplenum = 1\n",
        "plt.figure(figsize=(20,5))\n",
        "plt.title('Raw EEG signal')\n",
        "plt.plot(x_raw[samplenum])"
      ],
      "metadata": {
        "id": "m6v1IG3-9rIb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plt.figure(figsize=(20,5))\n",
        "plt.title('Preprocessed EEG signal')\n",
        "plt.plot(x[samplenum])"
      ],
      "metadata": {
        "id": "P-M0EXHJBaYU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VpMowosc0Bzf"
      },
      "source": [
        "## Splitting samples into training and testing dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "AjdvjsJ10JAe"
      },
      "outputs": [],
      "source": [
        "# caseid\n",
        "caseids = list(np.unique(c))\n",
        "random.shuffle(caseids)\n",
        "\n",
        "# Split dataset into training and testing data\n",
        "ntest = max(1, int(len(caseids) * 0.2))\n",
        "caseids_train = caseids[ntest:]\n",
        "caseids_test = caseids[:ntest]\n",
        "\n",
        "train_mask = np.isin(c, caseids_train)\n",
        "test_mask = np.isin(c, caseids_test)\n",
        "x_train = x[train_mask]\n",
        "y_train = y[train_mask]\n",
        "x_test = x[test_mask]\n",
        "y_test = y[test_mask]\n",
        "b_test = b[test_mask]\n",
        "c_test = c[test_mask]\n",
        "\n",
        "print('====================================================')\n",
        "print('total: {} cases {} samples'.format(len(caseids), len(y)))\n",
        "print('train: {} cases {} samples'.format(len(np.unique(c[train_mask])), len(y_train)))\n",
        "print('test {} cases {} samples'.format(len(np.unique(c_test)), len(y_test)))\n",
        "print('====================================================')"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Build model"
      ],
      "metadata": {
        "id": "k1h9403nJFLp"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![image.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "sIuazHsiLmgx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "######### TODO 3 #########\n",
        "import keras.models\n",
        "import tensorflow as tf\n",
        "from keras.models import Model\n",
        "from keras.layers import Layer, LayerNormalization, Dense, Dropout, Conv1D, MaxPooling1D, GlobalAveragePooling1D, GlobalMaxPooling1D, Input, concatenate, multiply, dot, MultiHeadAttention\n",
        "from keras.callbacks import EarlyStopping, ModelCheckpoint\n",
        "    \n",
        "clayer = 2 # Number of convolution layer\n",
        "fnode = 32 # Number of node in fully connected layer\n",
        "nfilt = 16 # Number of filter\n",
        "filtsize = 5 # Filter size\n",
        "pooltype = 'avg' # Pooling type\n",
        "poolsize = 2 # Pooling size\n",
        "droprate = 0.2   # Dropout rate in fully connected layer\n",
        "\n",
        "odir = '{}cases_{}sec'.format(MAX_CASES, SEGLEN // SRATE)\n",
        "odir += '_cnn{}+{} filt{} size{} pool{} {} do{}'.format(clayer+1, fnode, nfilt, filtsize, poolsize, pooltype, droprate)\n",
        "print(\"============================\")\n",
        "print(odir)\n",
        "print(\"============================\")\n",
        "\n",
        "######### TODO 3 : Step 1 #########\n",
        "\n",
        "# Make model using functional API\n",
        "out = inp = Input(shape=(x_train.shape[1], 1))\n",
        "\n",
        "#### INSERT CODE #### \n",
        "\n",
        "model.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ECKMG0Lp8geJ",
        "outputId": "490c2388-4b10-433d-beff-c61d3c80ee1b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "============================\n",
            "50cases_4sec_cnn3+32 filt16 size5 pool2 avg do0.2\n",
            "============================\n",
            "Model: \"model\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " input_1 (InputLayer)        [(None, 512, 1)]          0         \n",
            "                                                                 \n",
            " conv1d (Conv1D)             (None, 512, 16)           96        \n",
            "                                                                 \n",
            " max_pooling1d (MaxPooling1D  (None, 256, 16)          0         \n",
            " )                                                               \n",
            "                                                                 \n",
            " conv1d_1 (Conv1D)           (None, 256, 16)           1296      \n",
            "                                                                 \n",
            " max_pooling1d_1 (MaxPooling  (None, 128, 16)          0         \n",
            " 1D)                                                             \n",
            "                                                                 \n",
            " global_average_pooling1d (G  (None, 16)               0         \n",
            " lobalAveragePooling1D)                                          \n",
            "                                                                 \n",
            " dropout (Dropout)           (None, 16)                0         \n",
            "                                                                 \n",
            " dense (Dense)               (None, 32)                544       \n",
            "                                                                 \n",
            " dropout_1 (Dropout)         (None, 32)                0         \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 1)                 33        \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 1,969\n",
            "Trainable params: 1,969\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.keras.utils.plot_model(\n",
        "    model,\n",
        "    to_file='model.png',\n",
        "    show_shapes=True,\n",
        "    show_dtype=False,\n",
        "    show_layer_names=False,\n",
        "    rankdir='TB',\n",
        "    expand_nested=True,\n",
        "    dpi=96,\n",
        "    layer_range=None,\n",
        "    show_layer_activations=True,\n",
        ")"
      ],
      "metadata": {
        "id": "fu2DIpBOKTXe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Model train"
      ],
      "metadata": {
        "id": "8XVo4B_-JKy8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "######### TODO 4 #########\n",
        "\n",
        "######### TODO 4 : Step 1 #########\n",
        "#1 Compile model\n",
        "# 1) 손실함수: mean absolute error, 2) 평가방법: mean absolute error, 3) 옵티마이저: adam\n",
        "\n",
        "#### INSERT CODE #### \n",
        "\n",
        "######### TODO 4 : Step 2 #########\n",
        "#2 Train model\n",
        "# 1) validation split size: 20%, 2) epoch: 20 이상,  3) 미니배치크기: 1024,  4) Early stopping: 검증셋에서 mae 값이 3번 연속으로 더이상 감소하지 않을 시.\n",
        "\n",
        "#### INSERT CODE #### "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Oeh8YEY5I7DA",
        "outputId": "a91c1b88-262d-42bd-98a5-4318b87040ad"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/50\n",
            "281/281 [==============================] - 15s 15ms/step - loss: 0.3253 - mean_absolute_error: 0.3253 - val_loss: 0.1954 - val_mean_absolute_error: 0.1954\n",
            "Epoch 2/50\n",
            "281/281 [==============================] - 4s 14ms/step - loss: 0.2466 - mean_absolute_error: 0.2466 - val_loss: 0.1891 - val_mean_absolute_error: 0.1891\n",
            "Epoch 3/50\n",
            "281/281 [==============================] - 4s 14ms/step - loss: 0.2408 - mean_absolute_error: 0.2408 - val_loss: 0.1912 - val_mean_absolute_error: 0.1912\n",
            "Epoch 4/50\n",
            "281/281 [==============================] - 4s 13ms/step - loss: 0.2368 - mean_absolute_error: 0.2368 - val_loss: 0.1823 - val_mean_absolute_error: 0.1823\n",
            "Epoch 5/50\n",
            "281/281 [==============================] - 4s 13ms/step - loss: 0.2331 - mean_absolute_error: 0.2331 - val_loss: 0.1841 - val_mean_absolute_error: 0.1841\n",
            "Epoch 6/50\n",
            "281/281 [==============================] - 4s 14ms/step - loss: 0.2299 - mean_absolute_error: 0.2299 - val_loss: 0.2156 - val_mean_absolute_error: 0.2156\n",
            "Epoch 7/50\n",
            "281/281 [==============================] - 4s 13ms/step - loss: 0.2275 - mean_absolute_error: 0.2275 - val_loss: 0.2063 - val_mean_absolute_error: 0.2063\n",
            "Epoch 7: early stopping\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Inference"
      ],
      "metadata": {
        "id": "dtdtGhLhJNGA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "######### TODO 5 #########\n",
        "\n",
        "######### TODO 5 : Step 1 #########\n",
        "# Prediction on test set\n",
        "\n",
        "pred_test = #### INSERT CODE #### \n",
        "\n",
        "\n",
        "######### TODO 5 : Step2 #########\n",
        "# Calculate the total performance (mean absolute error)\n",
        "test_mae = #### INSERT CODE #### \n",
        "\n",
        "\n",
        "for caseid in np.unique(c_test):\n",
        "    case_mask = (c_test == caseid)\n",
        "    pred_test[case_mask] = scipy.signal.medfilt(pred_test[case_mask], 31)\n",
        "\n",
        "\n",
        "######### TODO 5 : Step3 #########\n",
        "# Evaluation\n",
        "for caseid in np.unique(c_test):\n",
        "    case_mask = (c_test == caseid)\n",
        "    case_len = #### INSERT CODE ####  # Calculate the length of each case\n",
        "    if case_len == 0:\n",
        "        continue\n",
        "\n",
        "    our_mae = #### INSERT CODE #### ) #Calculate the mean absolute error for each case\n",
        "    print('Total MAE={:.4f}, CaseID {}, MAE={:.4f}'.format(test_mae, caseid, our_mae))\n",
        "\n",
        "    t = np.arange(0, case_len)\n",
        "    plt.figure(figsize=(20, 5))\n",
        "    #### INSERT CODE #### # Plotting MAC \n",
        "    #### INSERT CODE #### # Plotting predicted MAC\n",
        "    plt.legend(loc=\"upper left\")\n",
        "    plt.tight_layout()\n",
        "    plt.xlim([0, case_len])\n",
        "    plt.ylim([0, 2])\n",
        "    plt.show()"
      ],
      "metadata": {
        "id": "_I__dsLcJC33"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "uldGged1NpJJ"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "collapsed_sections": [],
      "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.9.12"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}