notebooks/StepDetection_FinalTest.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "StepDetection_FinalTest.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "mount_file_id": "1Bt08QVVv5iiU57HQa4XDn1tzKTgOnUKD",
      "authorship_tag": "ABX9TyMGEfIzgEE9em4WaN3pzpu0",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/adrianrivadulla/FootNet_Development/blob/main/StepDetection_FinalTest.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BpBr8kkpcAga"
      },
      "source": [
        "# FINAL TEST\r\n",
        "\r\n",
        "The best model resulting from 5-fold cross-validation is updated and tested on the testing set.\r\n",
        "\r\n",
        "The notebook requires DataFolds.npy and TestFolds.npy to exist in StepDetectionStudy > Data directory. DataFolds.npy and TestingSet.npy were generated using the notebook called TrainTest_Split.npy.\r\n",
        "\r\n",
        "DataFolds contains five folds of participants that were used for 5-fold crossvalidation and TestingSet contains the participants that have been put aside for final testing and that have not taken part in any training step. This notebook concatenates the five folds in DataFolds and uses these data to update the best candidate model attained during 5-fold crossvalidation. Model parameters are updated for 5 epochs with no validation set. The updated model is then tested on the TestingSet.\r\n",
        "\r\n",
        "**Make sure you're running on GPU before starting the notebook** for faster performance.\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TMfIij_gRB9w"
      },
      "source": [
        "# Presettings"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NpkeBvSpYrkU"
      },
      "source": [
        "## Mount drive"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qDgR6j9fYXdl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fedec96c-7347-4fb1-f33d-cfedca53768e"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive/')"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Drive already mounted at /content/drive/; to attempt to forcibly remount, call drive.mount(\"/content/drive/\", force_remount=True).\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uDZN7eb2YYVx"
      },
      "source": [
        "## Make imports"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HLdoRMCPQ2ex"
      },
      "source": [
        "import os\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "import pickle\n",
        "import scipy.io"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Kmb6x-j_1h83"
      },
      "source": [
        "## Directories"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O9qs4dlC1ja5"
      },
      "source": [
        "datadir = '/content/drive/My Drive/StepDetectionStudy/Data'\n",
        "testdir = '/content/drive/My Drive/StepDetectionStudy/FinalTest'\n",
        "finalmodeldir = '/content/drive/My Drive/StepDetectionStudy/FinalModel'"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "50IQk8iVZQmF"
      },
      "source": [
        "# Helper functions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KfGFKpx6ayVn"
      },
      "source": [
        "## FlattenDataset\r\n",
        "\r\n",
        "Flattens an structed list containing participants in the first sublevel (DatasetList[0]) and trials in the following sublevel (DatasetList[0][0])"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-Gr4VkkUaxzi"
      },
      "source": [
        "def FlattenDataset(DatasetList):\n",
        "    FlatList = []\n",
        "    for participant in DatasetList:\n",
        "        for trial in participant:\n",
        "                FlatList = FlatList + trial\n",
        "                \n",
        "    return FlatList"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2aoY0OapBZlP"
      },
      "source": [
        "## StandardiseData\r\n",
        "\r\n",
        "Transforms X_train and X_val to z-scores using the mean and standard deviation of each variable in the training set X_train."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XN9XZ6syBcU2"
      },
      "source": [
        "def StandardiseData(X_train, X_val):\n",
        "    \n",
        "    # calculate standardising parameters\n",
        "    zero_mean = np.mean(np.hstack(X_train), axis=(0,1)) # mean of each variable\n",
        "    one_std = np.std(np.hstack(X_train), axis=(0,1)) # std of each variable\n",
        "\n",
        "    # standardise data\n",
        "    for i in range(len(X_train)):\n",
        "        for idim in range(len(zero_mean)):\n",
        "            X_train[i][:,:,idim] = (X_train[i][:,:,idim] - zero_mean[idim])/ one_std[idim]\n",
        "\n",
        "    for i in range(len(X_val)):\n",
        "        for idim in range(len(zero_mean)):\n",
        "            X_val[i][:,:,idim] = (X_val[i][:,:,idim] - zero_mean[idim])/ one_std[idim]\n",
        "        \n",
        "    return X_train, X_val, zero_mean, one_std"
      ],
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kcuQsdCQae86"
      },
      "source": [
        "## ListToPaddedArray\r\n",
        "\r\n",
        "Zero-pads MatList to arrays of maxlen. The padding is added at the beginning."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EfSyzLQVafcA"
      },
      "source": [
        "def ListToPaddedArray(MatList, maxlen):\n",
        "    \n",
        "    padded =np.empty((0,maxlen,MatList[0].shape[2]))\n",
        "    \n",
        "    for i in MatList:\n",
        "        ipad = np.pad(i,((0,0),(maxlen-i.shape[1], 0),(0,0)),'constant')\n",
        "        padded = np.vstack((padded, ipad))\n",
        "            \n",
        "    return padded"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q7A7fOhibJqr"
      },
      "source": [
        "## GetStepEvents\r\n",
        "\r\n",
        "Finds the first (foot-strike, fs) and last (toe-off, to) value in Labels that are > 0.51 i.e. contact. Labels is a list containing n strides."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "37siN5zUbKG7"
      },
      "source": [
        "def GetStepEvents(Labels):\n",
        "    \n",
        "    fs = []\n",
        "    to = []    \n",
        "    \n",
        "    for stride in Labels:\n",
        "      if len(stride.shape) == 2:\n",
        "        on = np.where(stride[:,0] >= 0.50)[0][0]\n",
        "        off = np.where(stride[on:,0] < 0.50)[0][0] + on\n",
        "        \n",
        "      elif len(stride.shape) == 3:\n",
        "        on = np.where(stride[0,:,0] >= 0.50)[0][0]\n",
        "        off = np.where(stride[0,on:,0] < 0.50)[0][0] + on\n",
        "        \n",
        "      fs.append(on)\n",
        "      to.append(off)\n",
        "\n",
        "    return fs, to"
      ],
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jwbVxy6ZbXKl"
      },
      "source": [
        "## PerformanceAssessment\r\n",
        "\r\n",
        "Compares the original labels (Y_labels) against the predicted ones (Y_hat). Foot-strike and toe-off are detected in both real and predicted labels using the GetStepEvents funciton and then the difference (in ms) is calculated. Error metrics including precision, RMSE, parametric Bland-Altman 95% limits of agreement, 99 percentile and max error are calculated. Bland-Altman plots are saved to savingdir including the fold code valfold in the name so they can be identified."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O-Z9rqUBbX2F"
      },
      "source": [
        "def PerformanceAssessment(Y_labels, Y_hat, metadata, savingdir, valfold):\n",
        "\n",
        "  # get gold standard contact events\n",
        "  fs, to = GetStepEvents(Y_labels)    \n",
        "\n",
        "  # get predicted contact events\n",
        "  fs_hat,to_hat = GetStepEvents(Y_hat)\n",
        "\n",
        "  # everything to milliseconds\n",
        "  lastBra = [i for i, trialname in enumerate(metadata) if 'RBDS' in trialname][-1]\n",
        "\n",
        "  fs_ms = np.zeros_like(fs, dtype=float)\n",
        "  to_ms = np.zeros_like(to, dtype=float)\n",
        "\n",
        "  fs_hat_ms = np.zeros_like(fs_hat, dtype=float)\n",
        "  to_hat_ms = np.zeros_like(to_hat, dtype=float)\n",
        "\n",
        "  for i in range(len(fs)):\n",
        "    if i <= lastBra:\n",
        "      fs_ms[i] = fs[i]*1/150\n",
        "      to_ms[i] = to[i]*1/150\n",
        "      fs_hat_ms[i] = fs_hat[i]*1/150\n",
        "      to_hat_ms[i] = to_hat[i]*1/150\n",
        "\n",
        "    else:\n",
        "      fs_ms[i] = fs[i]*1/200\n",
        "      to_ms[i] = to[i]*1/200\n",
        "      fs_hat_ms[i] = fs_hat[i]*1/200\n",
        "      to_hat_ms[i] = to_hat[i]*1/200\n",
        "\n",
        "  # calculate errors\n",
        "  ct_ms = to_ms - fs_ms\n",
        "  ct_hat_ms = to_hat_ms - fs_hat_ms\n",
        "\n",
        "  FSError = fs_ms - fs_hat_ms\n",
        "  TOError = to_ms - to_hat_ms\n",
        "  CTError = ct_ms - ct_hat_ms\n",
        "\n",
        "  ## Error metrics\n",
        "\n",
        "  # Precision\n",
        "  fs_prec = np.count_nonzero(FSError == 0)/len(FSError)*100\n",
        "  to_prec = np.count_nonzero(TOError == 0)/len(TOError)*100\n",
        "  ct_prec = np.count_nonzero(CTError == 0)/len(CTError)*100\n",
        "\n",
        "  # RMSE\n",
        "  rmse_fs = np.sqrt(np.mean(FSError**2))\n",
        "  rmse_to = np.sqrt(np.mean(TOError**2))\n",
        "  rmse_ct = np.sqrt(np.mean(CTError**2))\n",
        "\n",
        "  # Bland-Altman plots\n",
        "  plt.figure()\n",
        "  fs95top, fs95bottom = BlandAltmanPlot(fs_ms, fs_hat_ms, to_ms - fs_ms, valfold,'Contact_time (ms)','Error (ms)')\n",
        "  plt.savefig(savingdir + '/FSBAplot_' + valfold + '.jpg')\n",
        "\n",
        "  plt.figure()\n",
        "  to95top, to95bottom = BlandAltmanPlot(to_ms, to_hat_ms, to_ms - fs_ms, valfold,'Contact_time (ms)','Error (ms)')\n",
        "  plt.savefig(savingdir + '/TOBAplot_' + valfold + '.jpg')\n",
        "\n",
        "  plt.figure()\n",
        "  ct95top, ct95bottom = BlandAltmanPlot(ct_ms, ct_hat_ms, to_ms - fs_ms, valfold,'Contact_time (ms)','Error (ms)')\n",
        "  plt.savefig(savingdir + '/CTBAplot_' + valfold + '.jpg')\n",
        "\n",
        "  # 99 pctile\n",
        "  fs_99 = np.percentile(np.abs(FSError),99)\n",
        "  to_99 = np.percentile(np.abs(TOError),99)\n",
        "  ct_99 = np.percentile(np.abs(CTError),99)\n",
        "\n",
        "  # max error\n",
        "  max_fs_error = max(np.abs(FSError))\n",
        "  max_to_error = max(np.abs(TOError))\n",
        "  max_ct_error = max(np.abs(CTError))\n",
        "\n",
        "  # write it all out as a dictionary\n",
        "  summary = {\"precision\" : [fs_prec, to_prec, ct_prec],\n",
        "             \"rmse\" : [rmse_fs, rmse_to, rmse_ct],\n",
        "             \"95la\" : [[fs95top, fs95bottom], [to95top, to95bottom], [ct95top, ct95bottom]],\n",
        "             \"pctile_99\" : [fs_99, to_99, ct_99],\n",
        "             \"max_error\" : [max_fs_error, max_to_error, max_ct_error]}\n",
        "\n",
        "  return summary, fs_ms, fs_hat_ms, to_ms, to_hat_ms"
      ],
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N6fW1RpAbrH1"
      },
      "source": [
        "## BlandAltmanPlot\r\n",
        "\r\n",
        "\r\n",
        "Displays a Bland-Altman plot where the disagreement between two instruments (y-axis) is plotted against a variable t (time in this case for visualisation purposes, x-axis). The 95% limits of agreeement are calculated parametrically i.e. mean disagreement +- 1.96*sd disagreement) and returned as input. The figure includes the 0 line disagreement line, mean disasgreement line, upper and lower 95% limits of agreement and regression line between disagreement and variable t."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "24_EdGSibt-e"
      },
      "source": [
        "def BlandAltmanPlot(data1, data2, t, PlotTitle, XLabel, YLabel, *args, **kwargs):\n",
        "\n",
        "    data1     = np.asarray(data1)               # instrument 1\n",
        "    data2     = np.asarray(data2)               # instrument 2\n",
        "    mean      = np.mean([data1, data2], axis=0) # mean of instrument 1 and 2\n",
        "    diff      = data1 - data2                   # Difference between data1 and data2\n",
        "    bias      = np.mean(diff)                   # Mean of the difference\n",
        "    sd        = np.std(diff, axis=0)            # Standard deviation of the difference\n",
        "    toplim    = bias + 1.96*sd\n",
        "    bottomlim = bias - 1.96*sd\n",
        "    line      = np.polyfit(t, diff, 1)\n",
        "\n",
        "    plt.scatter(t, diff, *args, **kwargs)\n",
        "    plt.axhline(bias, color='red', linestyle='-')\n",
        "    plt.axhline(0, color='black', linestyle='-')\n",
        "    plt.axhline(toplim, color='black', linestyle='-')\n",
        "    plt.axhline(bottomlim, color='black', linestyle='-')\n",
        "\n",
        "    axes = plt.gca()\n",
        "    x = np.array(axes.get_xlim())\n",
        "    y = line[0] * x + line[1]\n",
        "    plt.plot(x, y, '--')\n",
        "    plt.axhspan(bias - 1.96*sd, bias + 1.96*sd , alpha=0.5, color='grey')\n",
        "\n",
        "    plt.title(PlotTitle)\n",
        "    plt.xlabel(XLabel)\n",
        "    plt.ylabel(YLabel)\n",
        " \n",
        "    return toplim, bottomlim"
      ],
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dwyqpepFdDl_"
      },
      "source": [
        "# Main "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ia2zPl6jHVU7"
      },
      "source": [
        "## Load data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fve8djkJHQJc"
      },
      "source": [
        "trainfolds = np.load(datadir + '/DataFolds.npy', allow_pickle=True)\n",
        "trainfolds = trainfolds.item()\n",
        "trainset = {}\n",
        "for key in list(trainfolds['Fold_0'].keys()):\n",
        "  trainset[key] = []\n",
        "  for fold in list(trainfolds.keys()):\n",
        "    trainset[key] = trainset[key] + trainfolds[fold][key] \n",
        "\n",
        "testset = np.load(datadir + '/TestingSet.npy', allow_pickle=True)\n",
        "testset = testset.item()"
      ],
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qqm-Q4KqADDJ"
      },
      "source": [
        "## Preprocessing"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RpmKda69AArw"
      },
      "source": [
        "# Flatten data\n",
        "for key in list(trainset.keys()):\n",
        "  trainset[key] = FlattenDataset(trainset[key])\n",
        "  testset[key] = FlattenDataset(testset[key])\n",
        "\n",
        "## Standardise data\n",
        "trainset['X'], testset['X'], zero_mean, one_std = StandardiseData(trainset['X'], testset['X'])\n",
        "\n",
        "## Padd data\n",
        "X_train = ListToPaddedArray(trainset['X'], 200)\n",
        "Y_train = ListToPaddedArray(trainset['Y'], 200)\n",
        "X_test = ListToPaddedArray(testset['X'], 200)\n",
        "Y_test = ListToPaddedArray(testset['Y'], 200)"
      ],
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SijdtbQeAYPS"
      },
      "source": [
        "## Model updating"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7u7ocDyQFxMd",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 435
        },
        "outputId": "0a779678-b9c3-4f9f-db92-6033a3378560"
      },
      "source": [
        "# Load model\n",
        "FootNet = keras.models.load_model(testdir + '/FootNet_best_candidate')\n",
        "\n",
        "# Update model weigths for 5 epochs\n",
        "history = FootNet.fit(X_train, Y_train, batch_size=200, epochs=5)\n",
        "plt.figure()\n",
        "plt.plot(history.history['binary_accuracy'])\n",
        "\n",
        "# add standardisation parameters to model\n",
        "FootNet._zero_mean = tf.Variable(zero_mean, trainable=False)\n",
        "FootNet._one_std = tf.Variable(one_std, trainable=False)\n",
        "\n",
        "# save model\n",
        "FootNet.save(finalmodeldir +'/FootNetModel')"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/5\n",
            "125/125 [==============================] - 339s 3s/step - loss: 0.0166 - binary_accuracy: 0.9898\n",
            "Epoch 2/5\n",
            "125/125 [==============================] - 328s 3s/step - loss: 0.0125 - binary_accuracy: 0.9919\n",
            "Epoch 3/5\n",
            "125/125 [==============================] - 328s 3s/step - loss: 0.0120 - binary_accuracy: 0.9923\n",
            "Epoch 4/5\n",
            "125/125 [==============================] - 325s 3s/step - loss: 0.0116 - binary_accuracy: 0.9925\n",
            "Epoch 5/5\n",
            "125/125 [==============================] - 321s 3s/step - loss: 0.0112 - binary_accuracy: 0.9928\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fnWJA3mkb2uk"
      },
      "source": [
        "## Model assessment\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OneA5MInb8kB",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 959
        },
        "outputId": "1a5109d0-fb0d-48e9-8425-16c115669602"
      },
      "source": [
        "# Predict contact phases\n",
        "y_hat = FootNet.predict(X_test)\n",
        "\n",
        "# get rid of noise in predictions due to padding\n",
        "for i, labelvector in enumerate(y_hat):\n",
        "  padend = np.where(labelvector[:,0] < 0.1)[0][0]\n",
        "  labelvector[:padend,0] = 0\n",
        "  y_hat[i] = labelvector\n",
        "\n",
        "# Calculate test accuracy\n",
        "test_acc = tf.keras.metrics.BinaryAccuracy()\n",
        "test_acc.update_state(Y_test, y_hat)\n",
        "test_accuracy = test_acc.result().numpy()\n",
        "print('Test accuracy: ' + str(test_accuracy))\n",
        "\n",
        "# Performance assessment\n",
        "summary = PerformanceAssessment(Y_test, y_hat, testset['meta'], testdir, 'Final_test') \n",
        "print(summary)"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Test accuracy: 0.9929304\n",
            "({'precision': [44.111570247933884, 37.33930211202938, 23.97842056932966], 'rmse': [0.004641006071244823, 0.005737438202084836, 0.007742504134215225], '95la': [[0.009404667384133134, -0.008741597289244857], [0.01196327358747535, -0.01028589372827731], [0.01564987237826766, -0.014635562613957896]], 'pctile_99': [0.013333333333333308, 0.015000000000000013, 0.020000000000000018], 'max_error': [0.020000000000000018, 0.025000000000000022, 0.033333333333333326]}, array([0.90666667, 0.9       , 0.9       , ..., 0.635     , 0.635     ,\n",
            "       0.635     ]), array([0.9       , 0.9       , 0.89333333, ..., 0.63      , 0.63      ,\n",
            "       0.63      ]), array([1.15333333, 1.14666667, 1.14666667, ..., 0.82      , 0.82      ,\n",
            "       0.82      ]), array([1.16 , 1.16 , 1.16 , ..., 0.82 , 0.82 , 0.815]))\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SyMcegEFcoE8"
      },
      "source": [
        "## Save performance metrics"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-d93hFo2cooM"
      },
      "source": [
        "#save history and performance summary in results dic\n",
        "results = {}\n",
        "results['summary'] = summary\n",
        "results['history'] = history.history\n",
        "with open(testdir +'/summary_'+ 'Final_test', 'wb') as f:\n",
        " pickle.dump(results, f)\n",
        "\n",
        "# save for final analysis in Matlab (paper)\n",
        "scipy.io.savemat(testdir + '/y_and_yhat.mat', dict(y=Y_test, yhat=y_hat, meta = testset['meta']))\n"
      ],
      "execution_count": 26,
      "outputs": []
    }
  ]
}