Time-Ahead-Basic-LSTM-Avg-Voxel-Entropy-Old-3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rN8VtTibW_kL"
   },
   "source": [
    "Set Colab to GPU Mode if you are training the models!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ESNkUUOEoS8j"
   },
   "source": [
    "### Mounting Google Drive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "GWpiHXuGn6Oy",
    "outputId": "2ccc1d4e-1516-4e2e-e666-e28ef97cde69"
   },
   "outputs": [],
   "source": [
    "# from google.colab import drive\n",
    "# drive.mount('/content/drive')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "bpxEP-yeoWPX",
    "outputId": "a581e75e-fd8e-47d4-a5fa-db65a86e8412"
   },
   "outputs": [],
   "source": [
    "# cd 'drive/MyDrive/IIT J Summer Internship 2022/Code/Neural-Uncertainty-Representation/'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Hq9mNRMMomT7"
   },
   "source": [
    "### Importing Necessary Libraries\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "id": "SRXBkwcIogPe"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "import tensorflow as tf\n",
    "\n",
    "from tensorflow.keras.layers import Dense, Dropout, LSTM, TimeDistributed\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.optimizers import Adam\n",
    "\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import os"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_R2-Cetmxned"
   },
   "source": [
    "### Importing Data\n",
    "We import the data of a old subject's 3D-Tensor Data of dimensions (TR, Voxel, Number of Subjects) for the 5 different ROIs as follows:\n",
    "- **Prefrontal areas:** dlPFC, vlPFC, lOFC, dmPFC, mPFC, mOFC\n",
    "- **Default-mode areas:** mPFC, ACC, PCC, Precuneus, mOFC\n",
    "- **Sensory areas:** VC\n",
    "- **Multisensory area:** pSTS\n",
    "- **Some other areas:** TP, IPL, mCC, Put, PCG, Nac, INS\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "id": "XUJPFBg1898z"
   },
   "outputs": [],
   "source": [
    "# file_names = [name for name in os.listdir('/content/drive/MyDrive/IIT J Summer Internship 2022/Hitchcock/Data/YOUNG/Voxel_BOLD/Numpy') if name.endswith(\"npy\") and (\"(1)\" not in name)]\n",
    "file_names = [name for name in os.listdir('./Data/OLD/Voxel_BOLD/Numpy') if name.endswith(\"npy\") and (\"(1)\" not in name)]\n",
    "file_names = [name for name in file_names if (\"537\" not in name)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "id": "5lVnzf5N_Ufy"
   },
   "outputs": [],
   "source": [
    "ROI_names = [file_name.replace(\"data_\",\"\").replace(\".npy\",\"\") for file_name in file_names]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "id": "Kg22rkIGpfP2"
   },
   "outputs": [],
   "source": [
    "data_ori = list()\n",
    "for file_name in file_names:\n",
    "    # data_ori.append(np.load('/content/drive/MyDrive/IIT J Summer Internship 2022/Hitchcock/Data/YOUNG/Voxel_BOLD/Numpy/'+file_name))\n",
    "    data_ori.append(np.load('./Data/OLD/Voxel_BOLD/Numpy/'+file_name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Kcaxzm8WDjgO"
   },
   "source": [
    "### Data Preparation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "K9rJ8CAb97K2"
   },
   "source": [
    "Now, here we prepare the data to be fed to the Neural Network Architechtures. Following on the previous developement of the LSTM model to predict BOLD, as a proxy to calculate **Uncertainty**, I use entropy at each time step."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "im3Oqy2ueeEU"
   },
   "source": [
    "Right from the starting we decide some of the data preparation parameters, so that we can use them as we require."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "id": "X1DoZ2Fcec20"
   },
   "outputs": [],
   "source": [
    "TRAIN_BATCH_SIZE = 10\n",
    "TEST_BATCH_SIZE = 8\n",
    "LOOK_AHEADS = list(range(1, 2)) \n",
    "NUM_TEST_SUBS = 8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TYuu8ZM2-u9z"
   },
   "source": [
    "We will start a basic data preparation where we will average across all the voxels for a ROI and fit the model which predicts this average BOLD value. Later we will avoid doing an average since, all voxels in a ROI is not equally important and hence we will want to predict the BOLD values of several voxels simultaneously."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "id": "pFvaFL69geft"
   },
   "outputs": [],
   "source": [
    "data = [np.mean(dat, axis=1, keepdims=True) for dat in data_ori]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mY3usMssn3T5"
   },
   "source": [
    "Let's Start the Data Preparation for lOFC later we will iterate the same procedure for the other ROIs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "71dv3Zkcgu3N",
    "outputId": "9dfa0cb6-dc7b-4404-cc7b-32268ad7201f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dlPFC Average BOLD Shape: (189, 1, 98)\n"
     ]
    }
   ],
   "source": [
    "print(ROI_names[-1], \"Average BOLD Shape:\", data[-1].shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jG7ofnvRczcN"
   },
   "source": [
    "Below, we see the average BOLD time series plot for all the ROIs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-wIOccLpE0d-"
   },
   "source": [
    "We have changed the data in the form (Number of Subjects, TR, Voxels) below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "id": "0pHK54KjDnah"
   },
   "outputs": [],
   "source": [
    "data = [np.transpose(dat, (2,0,1)) for dat in data]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "HRXHJ1cwgrzp",
    "outputId": "bb9ef066-2eae-47cc-deeb-4743cda8a59e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dlPFC Average BOLD Shape: (98, 189, 1)\n"
     ]
    }
   ],
   "source": [
    "print(ROI_names[-1], \"Average BOLD Shape:\", data[-1].shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "id": "AseI4ZNeg26E"
   },
   "outputs": [],
   "source": [
    "# for i in range(len(data)):  \n",
    "#   plt.figure(figsize=(10, 8))\n",
    "#   plt.plot(data[i][0,:,0])\n",
    "#   plt.title(\"Average BOLD of 1st Subject for \"+ROI_names[i])\n",
    "#   plt.xlabel(\"TRs\")\n",
    "#   plt.ylabel(\"Average BOLD(over voxels)\")\n",
    "#   plt.savefig(\"./Plots/YOUNG/AVG-BOLD/AVG-BOLD-\"+ROI_names[i]+\".png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gg50q17pp5xQ"
   },
   "source": [
    "We split the dataset of $98$ young subjects into $90$ subjects in the training data and $8$ subject in the test data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "id": "hrldyz8XnDlv"
   },
   "outputs": [],
   "source": [
    "train_data_unscaled = [dat[:-NUM_TEST_SUBS] for dat in data]\n",
    "test_data_unscaled = [dat[-NUM_TEST_SUBS:] for dat in data]  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MDV7H0sYt6jd"
   },
   "source": [
    "We scaled the BOLD values of each voxel in the train data between 0 and 1 for each voxel. We use the same MinMixScaler fit on the train data on the test data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "id": "-xkJQLj3tORj"
   },
   "outputs": [],
   "source": [
    "scalers = list()\n",
    "for i in range(len(ROI_names)):\n",
    "  scalers.append(MinMaxScaler(feature_range = (0, 1)))\n",
    "train_data = [sc.fit_transform(dat[:,:,0]) for sc, dat in zip(scalers, train_data_unscaled)] \n",
    "test_data = [sc.transform(dat[:,:,0]) for sc, dat in zip(scalers, test_data_unscaled)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "id": "Ail126iVuR6s"
   },
   "outputs": [],
   "source": [
    "train_data = [np.expand_dims(dat, axis = -1) for dat in train_data]\n",
    "test_data = [np.expand_dims(dat, axis = -1) for dat in test_data]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "_cOAv_VrnbLU",
    "outputId": "ca52cae0-fbc2-4a11-ae29-af58d9fe53e0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dlPFC Train Data Shape:  (90, 189, 1)\n",
      "dlPFC Test Data Shape:  (8, 189, 1)\n"
     ]
    }
   ],
   "source": [
    "print(ROI_names[-1], \"Train Data Shape: \", train_data[-1].shape)\n",
    "print(ROI_names[-1], \"Test Data Shape: \", test_data[-1].shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, for the purpose of binning which we will use for calculating entropy, each time point in BOLD signal, after standard scaling needs to be split up into regions based on the value being some standard deviation away from $0$. So, how to split the data is what we will decide here. I go with the split such that each bin contains equal number of values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "NUM_BINS = 30 # Per ROI how many bins should be there"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "def equalObs(x, nbin):\n",
    "  nlen = len(x)\n",
    "  return np.interp(np.linspace(0, nlen, nbin + 1), np.arange(nlen), np.sort(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "roi_bins = list()\n",
    "train_target = list()\n",
    "for roi_data in train_data:\n",
    "  _, bins, _ = plt.hist(np.squeeze(np.concatenate(roi_data)), equalObs(np.squeeze(np.concatenate(roi_data)), NUM_BINS))\n",
    "  # _, bins, _ = plt.hist(np.squeeze(np.concatenate(roi_data)), NUM_BINS)\n",
    "  plt.close()\n",
    "  roi_bins.append(bins)\n",
    "  train_target.append(np.sum(roi_data > np.tile(bins, roi_data.shape), axis=-1, keepdims=True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "31"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(roi_bins[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below, we generate the binned plots to see how the results look like for the first subject."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for i in range(len(data)):  \n",
    "#   plt.figure(figsize=(10, 8))\n",
    "#   plt.plot(train_data[i][0,:,0], label='Actual')\n",
    "#   plt.plot(roi_bins[i][train_target[i][0,:,0]], label='Binned')\n",
    "#   plt.legend()\n",
    "#   plt.title(\"Average BOLD of 1st Subject for \"+ROI_names[i]+\" with \"+str(NUM_BINS)+\" binned targets (Train Data Based Bins)\")\n",
    "#   plt.xlabel(\"TRs\")\n",
    "#   plt.ylabel(\"Average BOLD(over voxels)[Scaled between 0 and 1]\")\n",
    "#   plt.savefig(\"./Plots/OLD/AVG-BOLD/AVG-BOLD-SCALED-TRAIN-\"+str(NUM_BINS)+\"-BINS-\"+ROI_names[i]+\".png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, from the bins generated from the training data, I will use them to bin the test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_target = list()\n",
    "for roi_data, bins in zip(test_data, roi_bins):\n",
    "  test_target.append(np.sum(roi_data > np.tile(bins, roi_data.shape), axis=-1, keepdims=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0yjlAwWeiEru"
   },
   "source": [
    "We now build a data generator which would produce mini-batches during the training of the neural network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "id": "Blko7LXpgtwA"
   },
   "outputs": [],
   "source": [
    "class KerasBatchGenerator(object):\n",
    "    def __init__(self, data, bins_data, num_TRs, batch_size, look_ahead=1):\n",
    "        self.data = data\n",
    "        self.bins_data = bins_data\n",
    "        self.num_TRs = num_TRs\n",
    "        self.batch_size = batch_size\n",
    "        self.current_idx = 0\n",
    "        self.look_ahead = look_ahead\n",
    "\n",
    "    def generate(self):\n",
    "        while True:\n",
    "            if self.current_idx + self.batch_size >= self.data.shape[0]:\n",
    "              self.current_idx = 0\n",
    "            x = self.data[self.current_idx:(self.current_idx+self.batch_size),:(-self.look_ahead),:]\n",
    "            y = self.bins_data[self.current_idx:(self.current_idx+self.batch_size),self.look_ahead:,:]\n",
    "            self.current_idx = self.current_idx + self.batch_size\n",
    "            yield x, y "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "id": "lZN56Eg3mrsc"
   },
   "outputs": [],
   "source": [
    "train_data_generator, test_data_generator = list(), list()\n",
    "for LOOK_AHEAD in LOOK_AHEADS:\n",
    "    train_data_generator.append([KerasBatchGenerator(dat, bin_dat, dat.shape[1], TRAIN_BATCH_SIZE, LOOK_AHEAD) for dat, bin_dat in zip(train_data, train_target)])\n",
    "    test_data_generator.append([KerasBatchGenerator(dat, bin_dat, dat.shape[1], TEST_BATCH_SIZE, LOOK_AHEAD) for dat, bin_dat in zip(test_data, test_target)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "5UPT6iRxpJ7c",
    "outputId": "3512d1f5-6a04-4819-94b9-0229bc0cdef4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dlPFC Train Batch X Shape for 1 Ahead:  (10, 188, 1)\n",
      "dlPFC Train Batch y Shape for 1 Ahead:  (10, 188, 1)\n"
     ]
    }
   ],
   "source": [
    "batch_xs, batch_ys = list(), list()\n",
    "for LOOK_AHEAD in LOOK_AHEADS:\n",
    "    batch = next(train_data_generator[LOOK_AHEAD-1][-1].generate())\n",
    "    batch_xs.append(batch[0])\n",
    "    batch_ys.append(batch[1])\n",
    "    print(f\"{ROI_names[-1]} Train Batch X Shape for {LOOK_AHEAD} Ahead: \", batch_xs[LOOK_AHEAD-1].shape)\n",
    "    print(f\"{ROI_names[-1]} Train Batch y Shape for {LOOK_AHEAD} Ahead: \", batch_ys[LOOK_AHEAD-1].shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Clavfro-pSEV",
    "outputId": "2f9380f5-1bf0-47f7-c4c5-4fe25999be8a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dlPFC Test Batch X Shape for 1 Ahead:  (8, 188, 1)\n",
      "dlPFC Test Batch y Shape for 1 Ahead:  (8, 188, 1)\n"
     ]
    }
   ],
   "source": [
    "batch_xs, batch_ys = list(), list()\n",
    "for LOOK_AHEAD in LOOK_AHEADS:\n",
    "    batch = next(test_data_generator[LOOK_AHEAD-1][-1].generate())\n",
    "    batch_xs.append(batch[0])\n",
    "    batch_ys.append(batch[1])\n",
    "    print(f\"{ROI_names[-1]} Test Batch X Shape for {LOOK_AHEAD} Ahead: \", batch_xs[LOOK_AHEAD-1].shape)\n",
    "    print(f\"{ROI_names[-1]} Test Batch y Shape for {LOOK_AHEAD} Ahead: \", batch_ys[LOOK_AHEAD-1].shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "31NRewZjqoi1"
   },
   "source": [
    "### Building Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8Ry-jGmHqqx0"
   },
   "source": [
    "We will start off by building a LSTM Model:\n",
    "- `Number of LSTM Layers = 1`\n",
    "- `Number of Dense Layers = 2`\n",
    "- `hidden units = 32`\n",
    "- `dropout = 0.3`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "id": "AKDAJkiVgK2n"
   },
   "outputs": [],
   "source": [
    "HIDDEN_UNITS = 64\n",
    "DROPOUT_PROB = 0.3\n",
    "LSTM_LAYERS = 1\n",
    "DENSE_LAYERS = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "id": "fqoXwHTTqqCR"
   },
   "outputs": [],
   "source": [
    "def avg_bold_model():\n",
    "  model = Sequential()\n",
    "  for _ in range(LSTM_LAYERS):\n",
    "    model.add(LSTM(HIDDEN_UNITS, return_sequences=True))\n",
    "  model.add(Dropout(0.3))\n",
    "  for _ in range(DENSE_LAYERS-1):\n",
    "    model.add(TimeDistributed(Dense(HIDDEN_UNITS, activation='relu')))\n",
    "  model.add(TimeDistributed(Dense(NUM_BINS + 1, activation='softmax')))\n",
    "  return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "nYHgnyz-v5nA",
    "outputId": "9b71e39f-53a1-4ca7-a151-34fc6f874624"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "***1 Look Ahead Model***\n",
      "Metal device set to: Apple M1 Max\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-11-10 22:53:40.714420: I tensorflow/core/common_runtime/pluggable_device/pluggable_device_factory.cc:305] Could not identify NUMA node of platform GPU ID 0, defaulting to 0. Your kernel may not have been built with NUMA support.\n",
      "2022-11-10 22:53:40.714526: I tensorflow/core/common_runtime/pluggable_device/pluggable_device_factory.cc:271] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 0 MB memory) -> physical PluggableDevice (device: 0, name: METAL, pci bus id: <undefined>)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " lstm (LSTM)                 (8, 188, 64)              16896     \n",
      "                                                                 \n",
      " dropout (Dropout)           (8, 188, 64)              0         \n",
      "                                                                 \n",
      " time_distributed (TimeDistr  (8, 188, 64)             4160      \n",
      " ibuted)                                                         \n",
      "                                                                 \n",
      " time_distributed_1 (TimeDis  (8, 188, 64)             4160      \n",
      " tributed)                                                       \n",
      "                                                                 \n",
      " time_distributed_2 (TimeDis  (8, 188, 31)             2015      \n",
      " tributed)                                                       \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 27,231\n",
      "Trainable params: 27,231\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "for LOOK_AHEAD in LOOK_AHEADS:\n",
    "    print(f\"***{LOOK_AHEAD} Look Ahead Model***\")\n",
    "    sample_model = avg_bold_model()\n",
    "    sample_model.build(input_shape=batch_xs[LOOK_AHEAD-1].shape)\n",
    "    sample_model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "id": "fUZSBnNft2Dl"
   },
   "outputs": [],
   "source": [
    "models = [[avg_bold_model() for _ in ROI_names] for _ in LOOK_AHEADS]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3PRKFwUahAKG"
   },
   "source": [
    "#### Training Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LsHnfCSrhC0g"
   },
   "source": [
    "If you haven't already trained the models then uncomment and train your models which will be saved and will be loaded for inference later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "id": "kf-dFQmfzqTA"
   },
   "outputs": [],
   "source": [
    "for i in range(len(LOOK_AHEADS)):\n",
    "    for j in range(len(ROI_names)):\n",
    "        models[i][j].compile(optimizer = 'adam', loss = tf.keras.losses.SparseCategoricalCrossentropy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "id": "vcZsfhkz3lCH"
   },
   "outputs": [],
   "source": [
    "EPOCHS = 300\n",
    "checkpoint_filepaths = [[f\"./Models/OLD/LSTM/AVG-BINNED-BOLD/{name}/model_weights-best-val-loss-{LSTM_LAYERS}L-{HIDDEN_UNITS}H-{DENSE_LAYERS}D-{int(DROPOUT_PROB*10)}Drop-{LOOK_AHEAD}Ahead-{name}\" for name in ROI_names] for LOOK_AHEAD in LOOK_AHEADS]\n",
    "model_checkpoint_callbacks = [[tf.keras.callbacks.ModelCheckpoint(\n",
    "    filepath=checkpoint_filepat,\n",
    "    save_weights_only=True,\n",
    "    monitor = \"val_loss\",\n",
    "    mode='min',\n",
    "    save_best_only=True) for checkpoint_filepat in checkpoint_filepath] for checkpoint_filepath in checkpoint_filepaths]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "id": "wECZbf2i_AH7"
   },
   "outputs": [],
   "source": [
    "def plot_train_test_loss(history, model_name, i):  \n",
    "  plt.figure(figsize=(10,10))\n",
    "  plt.plot(history.history['loss'])\n",
    "  plt.plot(history.history['val_loss'])\n",
    "  plt.title(model_name+' loss')\n",
    "  plt.ylabel('loss')\n",
    "  plt.xlabel('epochs')\n",
    "  plt.legend(['train', 'val'], loc='upper left')\n",
    "  plt.savefig(\"./Plots/OLD/LSTM/AVG-BINNED-BOLD/\"+ROI_names[i]+\"/\"+model_name+\"-loss.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "AFb-kTLR21hl"
   },
   "outputs": [],
   "source": [
    "histories = list()\n",
    "with tf.device('/device:GPU:0'):\n",
    "    for LOOK_AHEAD in LOOK_AHEADS:\n",
    "        history = list()\n",
    "        for j in range(len(ROI_names)):\n",
    "            print(f'***{ROI_names[j]}***')\n",
    "            hist = models[LOOK_AHEAD-1][j].fit(\n",
    "                        train_data_generator[LOOK_AHEAD-1][j].generate(),\n",
    "                        steps_per_epoch=train_data[i].shape[0]//TRAIN_BATCH_SIZE,\n",
    "                        epochs=EPOCHS,\n",
    "                        validation_data=test_data_generator[LOOK_AHEAD-1][j].generate(),\n",
    "                        validation_steps=test_data[i].shape[0]//TEST_BATCH_SIZE,\n",
    "                        callbacks=[model_checkpoint_callbacks[LOOK_AHEAD-1][j]]\n",
    "                        )\n",
    "            models[LOOK_AHEAD-1][j].save_weights(f\"./Models/OLD/LSTM/AVG-BINNED-BOLD/{ROI_names[j]}/model_weights-{LSTM_LAYERS}L-{HIDDEN_UNITS}H-{DENSE_LAYERS}D-{int(DROPOUT_PROB*10)}Drop-{LOOK_AHEAD}Ahead-{ROI_names[j]}\")\n",
    "            plot_train_test_loss(hist, f\"{LSTM_LAYERS}L-{HIDDEN_UNITS}H-{DENSE_LAYERS}D-{int(DROPOUT_PROB*10)}Drop-{LOOK_AHEAD}Ahead-{ROI_names[j]}\", j)\n",
    "            history.append(hist)\n",
    "        histories.append(history)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "id": "dKvn0145hViW"
   },
   "outputs": [],
   "source": [
    "for LOOK_AHEAD in LOOK_AHEADS:\n",
    "    for i in range(len(ROI_names)):\n",
    "        models[LOOK_AHEAD-1][i].load_weights(f\"./Models/OLD/LSTM/AVG-BINNED-BOLD/{ROI_names[i]}/model_weights-{LSTM_LAYERS}L-{HIDDEN_UNITS}H-{DENSE_LAYERS}D-{int(DROPOUT_PROB*10)}Drop-{LOOK_AHEAD}Ahead-{ROI_names[i]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "id": "7mpQ5Rap6kQ0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 0s 40ms/step\n",
      "1/1 [==============================] - 0s 30ms/step\n",
      "1/1 [==============================] - 0s 30ms/step\n",
      "1/1 [==============================] - 0s 29ms/step\n",
      "1/1 [==============================] - 0s 30ms/step\n",
      "1/1 [==============================] - 0s 34ms/step\n",
      "1/1 [==============================] - 0s 30ms/step\n",
      "1/1 [==============================] - 0s 28ms/step\n",
      "1/1 [==============================] - 0s 31ms/step\n",
      "1/1 [==============================] - 0s 33ms/step\n",
      "1/1 [==============================] - 0s 34ms/step\n",
      "1/1 [==============================] - 0s 33ms/step\n",
      "1/1 [==============================] - 0s 32ms/step\n",
      "1/1 [==============================] - 0s 28ms/step\n",
      "1/1 [==============================] - 0s 30ms/step\n",
      "1/1 [==============================] - 0s 30ms/step\n",
      "1/1 [==============================] - 0s 27ms/step\n",
      "1/1 [==============================] - 0s 30ms/step\n",
      "1/1 [==============================] - 0s 32ms/step\n"
     ]
    }
   ],
   "source": [
    "preds_raw = [[models[LOOK_AHEAD-1][i].predict(next(test_data_generator[LOOK_AHEAD-1][i].generate())[0]) for i in range(len(ROI_names))] for LOOK_AHEAD in LOOK_AHEADS]\n",
    "preds = [[np.argmax(preds_raw[LOOK_AHEAD-1][i], axis=-1) for i in range(len(ROI_names))] for LOOK_AHEAD in LOOK_AHEADS]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "id": "9a4QShbkj8lk"
   },
   "outputs": [],
   "source": [
    "a_TRs = np.array([56, 67, 73, 81, 134, 142, 155, 167, 174, 180])\n",
    "d_TRs = np.array([67, 72, 85, 89, 145, 154, 168, 174, 180, 188])\n",
    "and_TRs = np.union1d(a_TRs, d_TRs)\n",
    "\n",
    "def highlight_and(act, pred):\n",
    "  min_y_list = list()\n",
    "  max_y_list = list()\n",
    "  for i in range(5):\n",
    "    min_y_list.append(np.min(np.concatenate([act[a_TRs[2*i]:d_TRs[2*i+1]], pred[a_TRs[2*i]:d_TRs[2*i+1]]])))\n",
    "    max_y_list.append(np.max(np.concatenate([act[a_TRs[2*i]:d_TRs[2*i+1]], pred[a_TRs[2*i]:d_TRs[2*i+1]]])))\n",
    "    plt.fill_betweenx(y=[min_y_list[i], max_y_list[i]], x1=a_TRs[2*i], x2=d_TRs[2*i+1], color='gray', alpha=0.1)\n",
    "    plt.fill_betweenx(y=[min_y_list[i], max_y_list[i]], x1=a_TRs[2*i], x2=a_TRs[2*i+1], color='violet', alpha=0.4)\n",
    "    plt.fill_betweenx(y=[min_y_list[i], max_y_list[i]], x1=d_TRs[2*i], x2=d_TRs[2*i+1], color='greenyellow', alpha=0.4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8, 188)"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "preds[0][-4].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8, 188)"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.squeeze(test_target[0])[:,1:].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "WBLOHLixAWnk"
   },
   "outputs": [],
   "source": [
    "for LOOK_AHEAD in LOOK_AHEADS:\n",
    "    for i in range(len(ROI_names)):\n",
    "      \n",
    "        actual_test_data_output = np.squeeze(test_target[i])[:,LOOK_AHEAD:] \n",
    "        pred_test_data_output = preds[LOOK_AHEAD-1][i]\n",
    "        plt.figure(figsize=(24, 18))\n",
    "\n",
    "        for j in range(NUM_TEST_SUBS):\n",
    "            ax = plt.subplot(3, 3, j + 1)\n",
    "            plt.plot(actual_test_data_output[j,:])\n",
    "            plt.plot(pred_test_data_output[j,:])\n",
    "            highlight_and(actual_test_data_output[j,:], pred_test_data_output[j,:])\n",
    "            plt.xticks(np.concatenate([np.array([0]), and_TRs - LOOK_AHEAD]), np.concatenate([np.array([LOOK_AHEAD]), and_TRs]))\n",
    "            plt.ylabel(\"Average Binned BOLD\")\n",
    "            plt.xlabel(\"TRs\")\n",
    "            plt.title(f\"Avg Binned BOLD Preds of {LSTM_LAYERS}L-{HIDDEN_UNITS}H-{DENSE_LAYERS}D-{int(DROPOUT_PROB*10)}Drop-{NUM_BINS}Bin-{LOOK_AHEAD}Ahead for {j+1}th Test Sub's {ROI_names[i]}\")\n",
    "            plt.legend(['actual', 'pred'])\n",
    "        plt.savefig(f\"./Plots/OLD/LSTM/AVG-BINNED-BOLD/{ROI_names[i]}/{LSTM_LAYERS}L-{HIDDEN_UNITS}H-{DENSE_LAYERS}D-{int(DROPOUT_PROB*10)}Drop-{NUM_BINS}Bin-{LOOK_AHEAD}Ahead-Preds.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "J8hiJzxcKFuz",
    "outputId": "deaa6d44-de0d-463a-c437-9324739e5f64"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "***Each Test Subject's Correlation Coefficient between 1 ahead predicted and actual average binned BOLD values for ROIs***\n",
      "\n",
      "INS for 1th sub: 0.03\n",
      "INS for 2th sub: -0.23\n",
      "INS for 3th sub: -0.01\n",
      "INS for 4th sub: -0.17\n",
      "INS for 5th sub: 0.33\n",
      "INS for 6th sub: 0.81\n",
      "INS for 7th sub: 0.39\n",
      "INS for 8th sub: 0.34\n",
      "PCC for 1th sub: 0.2\n",
      "PCC for 2th sub: 0.11\n",
      "PCC for 3th sub: 0.18\n",
      "PCC for 4th sub: 0.02\n",
      "PCC for 5th sub: 0.29\n",
      "PCC for 6th sub: 0.4\n",
      "PCC for 7th sub: 0.04\n",
      "PCC for 8th sub: 0.13\n",
      "Cau for 1th sub: 0.33\n",
      "Cau for 2th sub: 0.23\n",
      "Cau for 3th sub: 0.23\n",
      "Cau for 4th sub: 0.06\n",
      "Cau for 5th sub: 0.01\n",
      "Cau for 6th sub: 0.15\n",
      "Cau for 7th sub: 0.06\n",
      "Cau for 8th sub: 0.18\n",
      "mCC for 1th sub: 0.33\n",
      "mCC for 2th sub: -0.05\n",
      "mCC for 3th sub: -0.02\n",
      "mCC for 4th sub: 0.27\n",
      "mCC for 5th sub: 0.19\n",
      "mCC for 6th sub: 0.47\n",
      "mCC for 7th sub: -0.03\n",
      "mCC for 8th sub: 0.03\n",
      "mOFC for 1th sub: 0.75\n",
      "mOFC for 2th sub: 0.72\n",
      "mOFC for 3th sub: 0.67\n",
      "mOFC for 4th sub: 0.56\n",
      "mOFC for 5th sub: 0.55\n",
      "mOFC for 6th sub: 0.5\n",
      "mOFC for 7th sub: 0.78\n",
      "mOFC for 8th sub: 0.62\n",
      "l_OFC for 1th sub: -0.06\n",
      "l_OFC for 2th sub: 0.64\n",
      "l_OFC for 3th sub: 0.6\n",
      "l_OFC for 4th sub: 0.59\n",
      "l_OFC for 5th sub: 0.37\n",
      "l_OFC for 6th sub: 0.78\n",
      "l_OFC for 7th sub: 0.72\n",
      "l_OFC for 8th sub: 0.17\n",
      "vlPFC for 1th sub: 0.02\n",
      "vlPFC for 2th sub: 0.06\n",
      "vlPFC for 3th sub: -0.01\n",
      "vlPFC for 4th sub: 0.53\n",
      "vlPFC for 5th sub: 0.13\n",
      "vlPFC for 6th sub: 0.15\n",
      "vlPFC for 7th sub: -0.06\n",
      "vlPFC for 8th sub: 0.39\n",
      "dmPFC for 1th sub: 0.07\n",
      "dmPFC for 2th sub: 0.52\n",
      "dmPFC for 3th sub: 0.38\n",
      "dmPFC for 4th sub: 0.28\n",
      "dmPFC for 5th sub: 0.16\n",
      "dmPFC for 6th sub: 0.15\n",
      "dmPFC for 7th sub: 0.55\n",
      "dmPFC for 8th sub: 0.48\n",
      "VC for 1th sub: 0.55\n",
      "VC for 2th sub: 0.36\n",
      "VC for 3th sub: 0.04\n",
      "VC for 4th sub: 0.25\n",
      "VC for 5th sub: 0.25\n",
      "VC for 6th sub: 0.17\n",
      "VC for 7th sub: 0.4\n",
      "VC for 8th sub: 0.2\n",
      "mPFC for 1th sub: 0.09\n",
      "mPFC for 2th sub: 0.4\n",
      "mPFC for 3th sub: 0.46\n",
      "mPFC for 4th sub: 0.24\n",
      "mPFC for 5th sub: 0.56\n",
      "mPFC for 6th sub: 0.34\n",
      "mPFC for 7th sub: 0.8\n",
      "mPFC for 8th sub: 0.39\n",
      "pSTS for 1th sub: -0.01\n",
      "pSTS for 2th sub: 0.35\n",
      "pSTS for 3th sub: 0.27\n",
      "pSTS for 4th sub: 0.08\n",
      "pSTS for 5th sub: -0.0\n",
      "pSTS for 6th sub: 0.09\n",
      "pSTS for 7th sub: 0.01\n",
      "pSTS for 8th sub: 0.06\n",
      "TP for 1th sub: 0.56\n",
      "TP for 2th sub: 0.67\n",
      "TP for 3th sub: 0.85\n",
      "TP for 4th sub: 0.72\n",
      "TP for 5th sub: 0.74\n",
      "TP for 6th sub: 0.92\n",
      "TP for 7th sub: 0.83\n",
      "TP for 8th sub: 0.81\n",
      "IPL for 1th sub: 0.32\n",
      "IPL for 2th sub: 0.29\n",
      "IPL for 3th sub: 0.24\n",
      "IPL for 4th sub: 0.52\n",
      "IPL for 5th sub: 0.26\n",
      "IPL for 6th sub: 0.46\n",
      "IPL for 7th sub: 0.04\n",
      "IPL for 8th sub: 0.1\n",
      "Nac for 1th sub: 0.16\n",
      "Nac for 2th sub: 0.51\n",
      "Nac for 3th sub: 0.32\n",
      "Nac for 4th sub: -0.01\n",
      "Nac for 5th sub: 0.01\n",
      "Nac for 6th sub: 0.3\n",
      "Nac for 7th sub: 0.03\n",
      "Nac for 8th sub: 0.09\n",
      "ACC for 1th sub: nan\n",
      "ACC for 2th sub: 0.23\n",
      "ACC for 3th sub: 0.72\n",
      "ACC for 4th sub: 0.39\n",
      "ACC for 5th sub: -0.04\n",
      "ACC for 6th sub: 0.33\n",
      "ACC for 7th sub: 0.11\n",
      "ACC for 8th sub: 0.61\n",
      "PreCG for 1th sub: 0.24\n",
      "PreCG for 2th sub: 0.24\n",
      "PreCG for 3th sub: 0.14\n",
      "PreCG for 4th sub: 0.16\n",
      "PreCG for 5th sub: 0.16\n",
      "PreCG for 6th sub: 0.07\n",
      "PreCG for 7th sub: 0.02\n",
      "PreCG for 8th sub: 0.04\n",
      "AMY for 1th sub: 0.51\n",
      "AMY for 2th sub: 0.63\n",
      "AMY for 3th sub: 0.37\n",
      "AMY for 4th sub: 0.71\n",
      "AMY for 5th sub: 0.49\n",
      "AMY for 6th sub: 0.76\n",
      "AMY for 7th sub: 0.57\n",
      "AMY for 8th sub: 0.67\n",
      "Put for 1th sub: 0.12\n",
      "Put for 2th sub: 0.29\n",
      "Put for 3th sub: 0.15\n",
      "Put for 4th sub: 0.17\n",
      "Put for 5th sub: 0.21\n",
      "Put for 6th sub: 0.12\n",
      "Put for 7th sub: 0.44\n",
      "Put for 8th sub: 0.47\n",
      "dlPFC for 1th sub: 0.67\n",
      "dlPFC for 2th sub: 0.2\n",
      "dlPFC for 3th sub: 0.42\n",
      "dlPFC for 4th sub: 0.08\n",
      "dlPFC for 5th sub: 0.28\n",
      "dlPFC for 6th sub: 0.38\n",
      "dlPFC for 7th sub: 0.83\n",
      "dlPFC for 8th sub: 0.55\n",
      "\n",
      "***Average across test subjects Correlation Coefficient between 1 ahead predicted and actual average binned BOLD values for ROIs***\n",
      "\n",
      "INS: 0.19\n",
      "PCC: 0.17\n",
      "Cau: 0.16\n",
      "mCC: 0.15\n",
      "mOFC: 0.64\n",
      "l_OFC: 0.48\n",
      "vlPFC: 0.15\n",
      "dmPFC: 0.32\n",
      "VC: 0.28\n",
      "mPFC: 0.41\n",
      "pSTS: 0.11\n",
      "TP: 0.76\n",
      "IPL: 0.28\n",
      "Nac: 0.18\n",
      "ACC: 0.29\n",
      "PreCG: 0.13\n",
      "AMY: 0.59\n",
      "Put: 0.25\n",
      "dlPFC: 0.43\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/rishideychowdhury/Desktop/Neural-Uncertainty-Representation/env/lib/python3.8/site-packages/numpy/lib/function_base.py:2829: RuntimeWarning: invalid value encountered in true_divide\n",
      "  c /= stddev[:, None]\n",
      "/Users/rishideychowdhury/Desktop/Neural-Uncertainty-Representation/env/lib/python3.8/site-packages/numpy/lib/function_base.py:2830: RuntimeWarning: invalid value encountered in true_divide\n",
      "  c /= stddev[None, :]\n"
     ]
    }
   ],
   "source": [
    "TR_ROI_corr_subs, AVG_TR_ROI_corr_subs = list(), list()\n",
    "for LOOK_AHEAD in LOOK_AHEADS:\n",
    "    print(f\"***Each Test Subject's Correlation Coefficient between {LOOK_AHEAD} ahead predicted and actual average binned BOLD values for ROIs***\")\n",
    "    print()\n",
    "    avg_r = list()\n",
    "    ROI_corr_subs = list()\n",
    "    for i in range(len(ROI_names)):\n",
    "        actual_test_data_output = np.squeeze(test_target[i])[:,LOOK_AHEAD:] \n",
    "        pred_test_data_output = preds[LOOK_AHEAD-1][i]\n",
    "        corr_subs = list()\n",
    "        for j in range(NUM_TEST_SUBS):\n",
    "            corr_subs.append(np.round(np.corrcoef(actual_test_data_output[j,:], pred_test_data_output[j,:])[0,1], 2))\n",
    "            print(f\"{ROI_names[i]} for {j+1}th sub: {corr_subs[j]}\")\n",
    "        ROI_corr_subs.append(corr_subs)\n",
    "    TR_ROI_corr_subs.append(ROI_corr_subs)\n",
    "    print()\n",
    "\n",
    "    print(f\"***Average across test subjects Correlation Coefficient between {LOOK_AHEAD} ahead predicted and actual average binned BOLD values for ROIs***\")\n",
    "    print()\n",
    "    ROI_corr_subs = list()\n",
    "    for i in range(len(ROI_names)):\n",
    "        actual_test_data_output = np.squeeze(test_target[i])[:,LOOK_AHEAD:] \n",
    "        pred_test_data_output = preds[LOOK_AHEAD-1][i]\n",
    "        sum_r = 0\n",
    "        for j in range(NUM_TEST_SUBS):\n",
    "            correl = np.corrcoef(actual_test_data_output[j,:], pred_test_data_output[j,:])[0,1]\n",
    "            if not np.isnan(correl):\n",
    "              sum_r += correl\n",
    "        ROI_corr_subs.append(np.round(sum_r / NUM_TEST_SUBS, 2))\n",
    "        print(f\"{ROI_names[i]}: {ROI_corr_subs[i]}\")\n",
    "    AVG_TR_ROI_corr_subs.append(ROI_corr_subs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(19, 1, 8) (19, 1)\n"
     ]
    }
   ],
   "source": [
    "TR_ROI_corr_subs = np.transpose(np.array(TR_ROI_corr_subs), (1,0,2))\n",
    "AVG_TR_ROI_corr_subs = np.array(AVG_TR_ROI_corr_subs).T\n",
    "print(TR_ROI_corr_subs.shape, AVG_TR_ROI_corr_subs.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for i in range(len(ROI_names)):\n",
    "#     plt.figure(figsize=(24, 18))\n",
    "\n",
    "#     for j in range(NUM_TEST_SUBS-1):\n",
    "\n",
    "#         ax = plt.subplot(3, 3, j + 1)\n",
    "#         plt.plot(TR_ROI_corr_subs[i, :, j])\n",
    "#         plt.xticks(np.arange(1, 16))\n",
    "#         plt.ylabel(\"Correlation\")\n",
    "#         plt.xlabel(\"Ahead TRs\")\n",
    "#         plt.title(f\"Avg BOLD Corr of {LSTM_LAYERS}L-{HIDDEN_UNITS}H-{DENSE_LAYERS}D-{int(DROPOUT_PROB*10)}Drop for {j+1}th Test Sub's {ROI_names[i]}\")\n",
    "#     plt.savefig(f\"./Plots/YOUNG/LSTM/AVG-BOLD-TEST-ENLARGED/{ROI_names[i]}/{LSTM_LAYERS}L-{HIDDEN_UNITS}H-{DENSE_LAYERS}D-{int(DROPOUT_PROB*10)}Drop-Upto-15Ahead-Corrs.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for i in range(len(ROI_names)):\n",
    "#     plt.figure(figsize=(10, 10))\n",
    "#     plt.plot(AVG_TR_ROI_corr_subs[i])\n",
    "#     plt.xticks(np.arange(1, 16))\n",
    "#     plt.ylabel(\"Correlation\")\n",
    "#     plt.xlabel(\"Ahead TRs\")\n",
    "#     plt.title(f\"Avg BOLD Corr of {LSTM_LAYERS}L-{HIDDEN_UNITS}H-{DENSE_LAYERS}D-{int(DROPOUT_PROB*10)}Drop Across Test Subs\")\n",
    "#     plt.savefig(f\"./Plots/YOUNG/LSTM/AVG-BOLD-TEST-ENLARGED/{ROI_names[i]}/{LSTM_LAYERS}L-{HIDDEN_UNITS}H-{DENSE_LAYERS}D-{int(DROPOUT_PROB*10)}Drop-Upto-15Ahead-Corrs-Avg-Across-Subs.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "f8gPew9YMI2B",
    "outputId": "35e82a11-86f5-47ea-918c-cebfe07c90d6"
   },
   "outputs": [],
   "source": [
    "# for LOOK_AHEAD in LOOK_AHEADS:\n",
    "#     print(f\"***Model's Final MSE(Train) Loss between {LOOK_AHEAD} ahead predicted and actual average BOLD values for ROIs for the Train Subjects***\")\n",
    "#     print()\n",
    "#     for i in range(len(ROI_names)):\n",
    "#         print(ROI_names[i]+\":\", np.round(histories[LOOK_AHEAD-1][i].history['loss'][-1], 5))\n",
    "#     print()\n",
    "#     print(f\"***Model's Final MSE(Validation) Loss between {LOOK_AHEAD} ahead predicted and actual average BOLD values for ROIs for the Test Subjects***\")\n",
    "#     print()\n",
    "#     for i in range(len(ROI_names)):\n",
    "#         print(ROI_names[i]+\":\", np.round(histories[LOOK_AHEAD-1][i].history['val_loss'][-1], 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "***Model's Final CXT(Validation) Loss between 1 ahead predicted and actual avg voxel binned BOLD values for ROIs for the Test Subjects***\n",
      "\n",
      "INS for Each Validation Subject: [1.2920655 1.0232675 1.6760383 1.0652968 1.1702557 1.4276941 1.568854\n",
      " 1.4180449]\n",
      "INS : 1.3301895\n",
      "PCC for Each Validation Subject: [1.0145931 1.4911249 1.7006091 0.6393978 1.6717345 1.4762906 1.2830639\n",
      " 1.4606388]\n",
      "PCC : 1.3421816\n",
      "Cau for Each Validation Subject: [1.7296821  1.7306074  1.4725024  0.83410937 1.459614   1.5126748\n",
      " 0.84698    0.8124861 ]\n",
      "Cau : 1.299832\n",
      "mCC for Each Validation Subject: [1.3964611  0.9572339  0.8432738  1.0977805  1.7070559  1.0784343\n",
      " 1.5812386  0.90127426]\n",
      "mCC : 1.1953441\n",
      "mOFC for Each Validation Subject: [1.6976    1.6000735 1.6157185 1.7271446 1.7062753 1.058186  1.5748552\n",
      " 1.5965158]\n",
      "mOFC : 1.572046\n",
      "l_OFC for Each Validation Subject: [1.5005947 1.9165318 1.93931   1.8143177 1.770541  1.5569768 1.6765977\n",
      " 1.5965339]\n",
      "l_OFC : 1.7214255\n",
      "vlPFC for Each Validation Subject: [1.1649641  0.7236178  0.12204289 1.5126216  1.2713429  0.9405804\n",
      " 1.2663438  0.94349945]\n",
      "vlPFC : 0.9931266\n",
      "dmPFC for Each Validation Subject: [1.0318806 1.7944261 1.319222  1.4644438 1.5879315 1.5137001 1.0308264\n",
      " 1.4237742]\n",
      "dmPFC : 1.3957756\n",
      "VC for Each Validation Subject: [1.3726628 1.4073894 1.712415  1.4038693 1.4804428 1.4425923 1.7380673\n",
      " 1.7733216]\n",
      "VC : 1.5413451\n",
      "mPFC for Each Validation Subject: [1.3005978 1.7225043 1.6462601 1.0554649 1.3728203 1.1075088 1.0845248\n",
      " 1.3472497]\n",
      "mPFC : 1.3296163\n",
      "pSTS for Each Validation Subject: [0.7733533  1.4343983  0.65958154 0.77330047 1.574172   1.3696532\n",
      " 0.7260701  0.8210943 ]\n",
      "pSTS : 1.0164529\n",
      "TP for Each Validation Subject: [1.9909475 1.2042621 1.1058367 1.6732113 1.1486523 1.2529705 1.080459\n",
      " 1.6983224]\n",
      "TP : 1.3943326\n",
      "IPL for Each Validation Subject: [1.1344358  1.3864387  1.4784114  1.5798057  1.4969275  1.5146719\n",
      " 1.4670312  0.99262846]\n",
      "IPL : 1.3812938\n",
      "Nac for Each Validation Subject: [1.2944814  1.7249478  1.8306755  0.38036928 1.1925076  1.741889\n",
      " 1.2582757  0.2364605 ]\n",
      "Nac : 1.2074509\n",
      "ACC for Each Validation Subject: [0.09644904 1.6039401  1.3651534  1.3532648  0.54077125 1.520689\n",
      " 0.84229094 1.4179933 ]\n",
      "ACC : 1.0925689\n",
      "PreCG for Each Validation Subject: [0.72225744 1.3408284  0.8180549  1.3804156  0.796818   1.4863989\n",
      " 0.7843965  0.38500145]\n",
      "PreCG : 0.9642714\n",
      "AMY for Each Validation Subject: [0.13067581 1.9845129  1.0778567  1.8179052  2.0581827  1.6050558\n",
      " 1.8178194  1.5830343 ]\n",
      "AMY : 1.5093803\n",
      "Put for Each Validation Subject: [ 6.22079  13.793364 12.949153 11.721586 11.954349  4.266702 11.71027\n",
      "  8.626744]\n",
      "Put : 10.155369\n",
      "dlPFC for Each Validation Subject: [1.0631421  1.4347197  1.0251718  1.0269467  0.92405427 0.97395176\n",
      " 1.3904885  1.2185314 ]\n",
      "dlPFC : 1.1321257\n"
     ]
    }
   ],
   "source": [
    "CXT_subs, AVG_CXT_subs = list(), list()\n",
    "for LOOK_AHEAD in LOOK_AHEADS:\n",
    "    print(f\"***Model's Final CXT(Validation) Loss between {LOOK_AHEAD} ahead predicted and actual avg voxel binned BOLD values for ROIs for the Test Subjects***\")\n",
    "    print()\n",
    "    ROI_CXT_subs, ROI_AVG_CXT_subs = list(), list()\n",
    "    for i in range(len(ROI_names)):\n",
    "        actual_test_data_output = np.squeeze(test_target[i])[:,LOOK_AHEAD:] \n",
    "        pred_test_data_output = preds_raw[LOOK_AHEAD-1][i]\n",
    "        ROI_CXT_subs.append(np.mean(tf.keras.losses.sparse_categorical_crossentropy(actual_test_data_output, pred_test_data_output).numpy(), axis=-1))\n",
    "        print(ROI_names[i]+\" for Each Validation Subject:\", ROI_CXT_subs[i])\n",
    "        ROI_AVG_CXT_subs.append(np.mean(ROI_CXT_subs[i]))\n",
    "        print(ROI_names[i]+\" :\", ROI_AVG_CXT_subs[i])\n",
    "    CXT_subs.append(ROI_CXT_subs)\n",
    "    AVG_CXT_subs.append(ROI_AVG_CXT_subs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(19, 1, 8) (19, 1)\n"
     ]
    }
   ],
   "source": [
    "CXT_subs = np.transpose(np.array(CXT_subs), (1, 0, 2))\n",
    "AVG_CXT_subs = np.array(AVG_CXT_subs).T\n",
    "print(CXT_subs.shape, AVG_CXT_subs.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for i in range(len(ROI_names)):\n",
    "#     plt.figure(figsize=(24, 18))\n",
    "\n",
    "#     for j in range(NUM_TEST_SUBS-1):\n",
    "\n",
    "#         ax = plt.subplot(3, 3, j + 1)\n",
    "#         plt.plot(MSE_subs[i, :, j])\n",
    "#         plt.xticks(np.arange(1, 16))\n",
    "#         plt.ylabel(\"MSE Loss\")\n",
    "#         plt.xlabel(\"Ahead TRs\")\n",
    "#         plt.title(f\"Avg BOLD MSE Losses of {LSTM_LAYERS}L-{HIDDEN_UNITS}H-{DENSE_LAYERS}D-{int(DROPOUT_PROB*10)}Drop for {j+1}th Test Sub's {ROI_names[i]}\")\n",
    "#     plt.savefig(f\"./Plots/YOUNG/LSTM/AVG-BOLD-TEST-ENLARGED/{ROI_names[i]}/{LSTM_LAYERS}L-{HIDDEN_UNITS}H-{DENSE_LAYERS}D-{int(DROPOUT_PROB*10)}Drop-Upto-15Ahead-Losses.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for i in range(len(ROI_names)):\n",
    "#     plt.figure(figsize=(10, 10))\n",
    "#     plt.plot(AVG_MSE_subs[i])\n",
    "#     plt.xticks(np.arange(1, 16))\n",
    "#     plt.ylabel(\"MSE Loss\")\n",
    "#     plt.xlabel(\"Ahead TRs\")\n",
    "#     plt.title(f\"Avg BOLD MSE Losses of {LSTM_LAYERS}L-{HIDDEN_UNITS}H-{DENSE_LAYERS}D-{int(DROPOUT_PROB*10)}Drop Across Test Subs\")\n",
    "#     plt.savefig(f\"./Plots/YOUNG/LSTM/AVG-BOLD-TEST-ENLARGED/{ROI_names[i]}/{LSTM_LAYERS}L-{HIDDEN_UNITS}H-{DENSE_LAYERS}D-{int(DROPOUT_PROB*10)}Drop-Upto-15Ahead-Losses-Avg-Across-Subs.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for LOOK_AHEAD in LOOK_AHEADS:\n",
    "  for i in range(len(ROI_names)):\n",
    "    entropy = -1 * np.sum(preds_raw[LOOK_AHEAD-1][i]*np.log(preds_raw[LOOK_AHEAD-1][i]), axis=-1)\n",
    "    plt.figure(figsize=(24, 18))\n",
    "    for j in range(NUM_TEST_SUBS):\n",
    "      \n",
    "      ax = plt.subplot(3, 3, j + 1)\n",
    "      plt.plot(entropy[j,:])\n",
    "      highlight_and(entropy[j,:], entropy[j,:])\n",
    "      plt.xticks(np.concatenate([np.array([0]), and_TRs - LOOK_AHEAD]), np.concatenate([np.array([LOOK_AHEAD]), and_TRs]))\n",
    "      plt.ylabel(\"Entropy of preds avg binned BOLD\")\n",
    "      plt.xlabel(\"TRs\")\n",
    "      plt.title(f\"Entropy Avg BOLD of {LSTM_LAYERS}L-{HIDDEN_UNITS}H-{DENSE_LAYERS}D-{int(DROPOUT_PROB*10)}Drop-{NUM_BINS}Bin-{LOOK_AHEAD}Ahead for {j+1}th Test Sub's {ROI_names[i]}\")\n",
    "    plt.savefig(f\"./Plots/OLD/LSTM/AVG-BINNED-BOLD/{ROI_names[i]}/{LSTM_LAYERS}L-{HIDDEN_UNITS}H-{DENSE_LAYERS}D-{int(DROPOUT_PROB*10)}Drop-{NUM_BINS}Bin-{LOOK_AHEAD}Ahead-Preds-Entropy.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for LOOK_AHEAD in LOOK_AHEADS:\n",
    "  entropy = [-1 * np.sum(preds_raw[LOOK_AHEAD-1][i]*np.log(preds_raw[LOOK_AHEAD-1][i]), axis=-1) for i in range(len(ROI_names))]\n",
    "  entropy_avg = [np.mean(entropy_ind, axis=0) for entropy_ind in entropy]\n",
    "  for i in range(len(ROI_names)):\n",
    "    plt.figure(figsize=(10, 10))\n",
    "    plt.plot(entropy_avg[i])\n",
    "    highlight_and(entropy_avg[i], entropy_avg[i])\n",
    "    plt.xticks(np.concatenate([np.array([0]), and_TRs - LOOK_AHEAD]), np.concatenate([np.array([LOOK_AHEAD]), and_TRs]))\n",
    "    plt.ylabel(\"Entropy of preds avg binned BOLD\")\n",
    "    plt.xlabel(\"TRs\")\n",
    "    plt.title(f\"Entropy Avg BOLD of {LSTM_LAYERS}L-{HIDDEN_UNITS}H-{DENSE_LAYERS}D-{int(DROPOUT_PROB*10)}Drop-{NUM_BINS}Bin-{LOOK_AHEAD}Ahead for All Test Subs Averaged {ROI_names[i]}\")\n",
    "    plt.savefig(f\"./Plots/OLD/LSTM/AVG-BINNED-BOLD/{ROI_names[i]}/{LSTM_LAYERS}L-{HIDDEN_UNITS}H-{DENSE_LAYERS}D-{int(DROPOUT_PROB*10)}Drop-{NUM_BINS}Bin-{LOOK_AHEAD}Ahead-Preds-All-Averaged-Entropy.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "authorship_tag": "ABX9TyO379dB7oIxYoBIQaqTB5jX",
   "collapsed_sections": [],
   "name": "Neural-Prediction-Uncertainty-Young-All-TestSet-Enlarged-LSTM-Layers-Increased-Hidden-Units-Increased-Dense-Layers-Increased.ipynb",
   "provenance": []
  },
  "gpuClass": "standard",
  "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}