Basic_LSTM_Model_All_Voxel_4.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": "9ffd7748-d379-4a2a-9beb-cc38794ee077"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ],
      "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": "e2ca7be9-b09f-4a6a-8ec7-ef9b2bec9414"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/content/drive/.shortcut-targets-by-id/1h_oF16bG32l75GPobgHe_9HgdUduLFxT/IIT J Summer Internship 2022/Code/Neural-Uncertainty-Representation\n"
          ]
        }
      ],
      "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": 3,
      "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 young 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": 4,
      "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 file_names if (\"537\" not in name)]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "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": 6,
      "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))"
      ]
    },
    {
      "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. We can't predict the time ahead upto which the subjects are predicting correctly so, we will take a bit round about way to predict the BOLD values ahead in time(for several choices of time points e.g. 1 time point ahead, 2 time point ahead, etc) and will compare the results for young and old subjects."
      ]
    },
    {
      "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": 7,
      "metadata": {
        "id": "X1DoZ2Fcec20"
      },
      "outputs": [],
      "source": [
        "TRAIN_BATCH_SIZE = 20\n",
        "TEST_BATCH_SIZE = 10\n",
        "LOOK_AHEAD = 1\n",
        "NUM_TEST_SUBS = 10"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TYuu8ZM2-u9z"
      },
      "source": [
        "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": 8,
      "metadata": {
        "id": "pFvaFL69geft"
      },
      "outputs": [],
      "source": [
        "data = 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": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "71dv3Zkcgu3N",
        "outputId": "64a08494-e336-458d-bb60-9b10ddf0d437"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "lOFC BOLD Shape: (189, 537, 111)\n"
          ]
        }
      ],
      "source": [
        "print(ROI_names[-1], \"BOLD Shape:\", data[-1].shape)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jG7ofnvRczcN"
      },
      "source": [
        "Below, we see the 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": 10,
      "metadata": {
        "id": "0pHK54KjDnah"
      },
      "outputs": [],
      "source": [
        "data = [np.transpose(dat, (2,0,1)) for dat in data]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HRXHJ1cwgrzp",
        "outputId": "2d5edc75-e5c9-426f-bcfb-c446e2e82f76"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "lOFC BOLD Shape: (111, 189, 537)\n"
          ]
        }
      ],
      "source": [
        "print(ROI_names[-1], \"BOLD Shape:\", data[-1].shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "AseI4ZNeg26E"
      },
      "outputs": [],
      "source": [
        "# for i in range(len(data)):  \n",
        "#   plt.figure(figsize=(10, 8))\n",
        "#   plt.plot(data[i][0,:,:])\n",
        "#   plt.title(\"BOLD of 1st Subject for \"+ROI_names[i]+\"'s Voxels\")\n",
        "#   plt.xlabel(\"TRs\")\n",
        "#   plt.ylabel(\"BOLD\")\n",
        "#   plt.savefig(\"./Plots/YOUNG/ALL-BOLD/ALL-BOLD-\"+ROI_names[i]+\".png\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gg50q17pp5xQ"
      },
      "source": [
        "We split the dataset of 111 young subjects into 101 subjects in the training data and 10 subject in the test data."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "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 MinMaxScaler fit on the train data on the test data."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "-xkJQLj3tORj"
      },
      "outputs": [],
      "source": [
        "scalers = dict() # Stores a list of MinMaxScalers for each ROI, where number of MinMaxScalers is equal to the number of voxels in that ROI\n",
        "for i in range(len(ROI_names)):\n",
        "  scalers[ROI_names[i]] = [MinMaxScaler(feature_range = (0, 1)) for _ in range(data[i].shape[-1])]\n",
        "\n",
        "train_data = [[scalers[ROI_names[j]][i].fit_transform(train_data_unscaled[j][:,:,i]) for i in range(len(scalers[ROI_names[j]]))] for j in range(len(ROI_names))]\n",
        "test_data = [[scalers[ROI_names[j]][i].transform(test_data_unscaled[j][:,:,i]) for i in range(len(scalers[ROI_names[j]]))] for j in range(len(ROI_names))]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "Ail126iVuR6s"
      },
      "outputs": [],
      "source": [
        "train_data = [np.transpose(np.array(dat), (1,2,0)) for dat in train_data]\n",
        "test_data = [np.transpose(np.array(dat), (1,2,0)) for dat in test_data]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_cOAv_VrnbLU",
        "outputId": "9bc3617f-4b24-41aa-d524-d288eb76d92e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "lOFC Train Data Shape:  (101, 189, 537)\n",
            "lOFC Test Data Shape:  (10, 189, 537)\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": "code",
      "execution_count": 17,
      "metadata": {
        "id": "YIlJSRX92txN"
      },
      "outputs": [],
      "source": [
        "# for i in range(len(data)):  \n",
        "#   plt.figure(figsize=(10, 8))\n",
        "#   plt.plot(train_data[i][0,:,:])\n",
        "#   plt.title(\"BOLD of 1st Subject for \"+ROI_names[i]+\"'s Voxels\")\n",
        "#   plt.xlabel(\"TRs\")\n",
        "#   plt.ylabel(\"BOLD[Scaled between 0 and 1]\")\n",
        "#   plt.savefig(\"./Plots/YOUNG/ALL-BOLD/ALL-BOLD-SCALED-\"+ROI_names[i]+\".png\")"
      ]
    },
    {
      "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": 18,
      "metadata": {
        "id": "Blko7LXpgtwA"
      },
      "outputs": [],
      "source": [
        "class KerasBatchGenerator(object):\n",
        "    def __init__(self, data, num_TRs, batch_size, look_ahead=1):\n",
        "        self.data = 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.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": 19,
      "metadata": {
        "id": "lZN56Eg3mrsc"
      },
      "outputs": [],
      "source": [
        "train_data_generator = [KerasBatchGenerator(dat, dat.shape[1], TRAIN_BATCH_SIZE, LOOK_AHEAD) for dat in train_data]\n",
        "test_data_generator = [KerasBatchGenerator(dat, dat.shape[1], TEST_BATCH_SIZE, LOOK_AHEAD) for dat in test_data]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5UPT6iRxpJ7c",
        "outputId": "9d8f3e89-7aba-4565-ab9b-73a03492367d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "lOFC Train Batch X Shape:  (20, 188, 537)\n",
            "lOFC Train Batch y Shape:  (20, 188, 537)\n"
          ]
        }
      ],
      "source": [
        "batch_x, batch_y = next(train_data_generator[-1].generate())\n",
        "print(ROI_names[-1], \"Train Batch X Shape: \", batch_x.shape)\n",
        "print(ROI_names[-1], \"Train Batch y Shape: \", batch_y.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Clavfro-pSEV",
        "outputId": "eea01fb6-fc18-491d-ac3c-8c6150eb8114"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "lOFC Test Batch X Shape:  (10, 188, 537)\n",
            "lOFC Test Batch y Shape:  (10, 188, 537)\n"
          ]
        }
      ],
      "source": [
        "batch_x, batch_y = next(test_data_generator[-1].generate())\n",
        "print(ROI_names[-1], \"Test Batch X Shape: \", batch_x.shape)\n",
        "print(ROI_names[-1], \"Test Batch y Shape: \", batch_y.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 = 2`\n",
        "- `Number of Dense Layers = 4`\n",
        "- `hidden units = 16`\n",
        "- `dropout = 0.3`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "id": "AKDAJkiVgK2n"
      },
      "outputs": [],
      "source": [
        "HIDDEN_UNITS = 16\n",
        "DROPOUT_PROB = 0.3\n",
        "LSTM_LAYERS = 2\n",
        "DENSE_LAYERS = 4"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "id": "fqoXwHTTqqCR"
      },
      "outputs": [],
      "source": [
        "def avg_bold_model(num_voxs):\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_voxs)))\n",
        "  return model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nYHgnyz-v5nA",
        "outputId": "83ecf640-f924-46bf-bc34-4cd18768b663"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " lstm (LSTM)                 (10, 188, 16)             35456     \n",
            "                                                                 \n",
            " lstm_1 (LSTM)               (10, 188, 16)             2112      \n",
            "                                                                 \n",
            " dropout (Dropout)           (10, 188, 16)             0         \n",
            "                                                                 \n",
            " time_distributed (TimeDistr  (10, 188, 16)            272       \n",
            " ibuted)                                                         \n",
            "                                                                 \n",
            " time_distributed_1 (TimeDis  (10, 188, 16)            272       \n",
            " tributed)                                                       \n",
            "                                                                 \n",
            " time_distributed_2 (TimeDis  (10, 188, 16)            272       \n",
            " tributed)                                                       \n",
            "                                                                 \n",
            " time_distributed_3 (TimeDis  (10, 188, 537)           9129      \n",
            " tributed)                                                       \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 47,513\n",
            "Trainable params: 47,513\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "sample_model = avg_bold_model(batch_x.shape[-1])\n",
        "sample_model.build(input_shape=batch_x.shape)\n",
        "sample_model.summary()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "id": "fUZSBnNft2Dl"
      },
      "outputs": [],
      "source": [
        "models = [avg_bold_model(train_data[i].shape[-1]) for i in range(len(ROI_names))]"
      ]
    },
    {
      "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": 26,
      "metadata": {
        "id": "kf-dFQmfzqTA"
      },
      "outputs": [],
      "source": [
        "for i in range(len(ROI_names)):\n",
        "  models[i].compile(optimizer = 'adam', loss = 'mean_squared_error')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {
        "id": "vcZsfhkz3lCH"
      },
      "outputs": [],
      "source": [
        "EPOCHS = 100\n",
        "checkpoint_filepaths = [f\"./Models/YOUNG/LSTM/ALL-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]\n",
        "model_checkpoint_callbacks = [tf.keras.callbacks.ModelCheckpoint(\n",
        "    filepath=checkpoint_filepath,\n",
        "    save_weights_only=True,\n",
        "    monitor = \"val_loss\",\n",
        "    mode='min',\n",
        "    save_best_only=True) for checkpoint_filepath in checkpoint_filepaths]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "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/YOUNG/LSTM/ALL-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 i in range(len(ROI_names)):\n",
        "    history = models[i].fit(\n",
        "                    train_data_generator[i].generate(),\n",
        "                    steps_per_epoch=train_data[i].shape[0]//TRAIN_BATCH_SIZE,\n",
        "                    epochs=EPOCHS,\n",
        "                    validation_data=test_data_generator[i].generate(),\n",
        "                    validation_steps=test_data[i].shape[0]//TEST_BATCH_SIZE,\n",
        "                    callbacks=[model_checkpoint_callbacks[i]]\n",
        "                    )\n",
        "    models[i].save_weights(f\"./Models/YOUNG/LSTM/ALL-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]}\")\n",
        "    plot_train_test_loss(history, f\"{LSTM_LAYERS}L-{HIDDEN_UNITS}H-{DENSE_LAYERS}D-{int(DROPOUT_PROB*10)}Drop-{LOOK_AHEAD}Ahead-{ROI_names[i]}\", i)\n",
        "    histories.append(history)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {
        "id": "dKvn0145hViW"
      },
      "outputs": [],
      "source": [
        "for i in range(len(ROI_names)):\n",
        "  models[i].load_weights(f\"./Models/YOUNG/LSTM/ALL-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": null,
      "metadata": {
        "id": "7mpQ5Rap6kQ0"
      },
      "outputs": [],
      "source": [
        "preds = [models[i].predict(next(test_data_generator[i].generate())[0]) for i in range(len(ROI_names))]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {
        "id": "HeE2zhmXxOge"
      },
      "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": null,
      "metadata": {
        "id": "WBLOHLixAWnk"
      },
      "outputs": [],
      "source": [
        "np.random.seed(43)\n",
        "for i in range(len(ROI_names)):\n",
        "  \n",
        "  actual_test_data_output = test_data_unscaled[i][:,LOOK_AHEAD:,:]\n",
        "  pred_test_data_output = np.transpose(np.array([scalers[ROI_names[i]][j].inverse_transform(np.hstack([preds[i][:,:,j], preds[i][:,:LOOK_AHEAD,j]])) for j in range(len(scalers[ROI_names[i]]))]), (1,2,0))[:,:-LOOK_AHEAD,:]\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",
        "    vox_choice = np.random.randint(0, len(scalers[ROI_names[i]]), 5)\n",
        "    plt.plot(np.transpose(actual_test_data_output[j,:, vox_choice]), c='b', label='actual')\n",
        "    plt.plot(np.transpose(pred_test_data_output[j,:, vox_choice]), c='r', ls='--', label='pred')\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(\"BOLD\")\n",
        "    plt.xlabel(\"TRs\")\n",
        "    plt.title(f\"All BOLD Preds of {LSTM_LAYERS}L-{HIDDEN_UNITS}H-{DENSE_LAYERS}D-{int(DROPOUT_PROB*10)}Drop-{LOOK_AHEAD}Ahead for {j+1}th Test Sub's {ROI_names[i]}\")\n",
        "    plt.legend()\n",
        "    plt.savefig(f\"./Plots/YOUNG/LSTM/ALL-BOLD/{ROI_names[i]}/{LSTM_LAYERS}L-{HIDDEN_UNITS}H-{DENSE_LAYERS}D-{int(DROPOUT_PROB*10)}Drop-{LOOK_AHEAD}Ahead-Preds.png\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {
        "id": "J8hiJzxcKFuz",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "63b61b48-d1af-4581-8a89-4d947fc9e651"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "***Each Test Subject's Correlation Coefficient between predicted and actual BOLD averaged across each Voxel Prediction values for ROIs***\n",
            "\n",
            "dmPFC for 1th sub: 0.29\n",
            "dmPFC for 2th sub: 0.36\n",
            "dmPFC for 3th sub: 0.28\n",
            "dmPFC for 4th sub: 0.15\n",
            "dmPFC for 5th sub: 0.12\n",
            "dmPFC for 6th sub: 0.4\n",
            "dmPFC for 7th sub: 0.12\n",
            "dmPFC for 8th sub: 0.28\n",
            "dmPFC for 9th sub: 0.41\n",
            "dmPFC for 10th sub: 0.17\n",
            "\n",
            "ACC for 1th sub: 0.26\n",
            "ACC for 2th sub: 0.27\n",
            "ACC for 3th sub: 0.06\n",
            "ACC for 4th sub: 0.15\n",
            "ACC for 5th sub: 0.13\n",
            "ACC for 6th sub: 0.23\n",
            "ACC for 7th sub: 0.17\n",
            "ACC for 8th sub: 0.49\n",
            "ACC for 9th sub: 0.25\n",
            "ACC for 10th sub: 0.32\n",
            "\n",
            "AMY for 1th sub: 0.23\n",
            "AMY for 2th sub: 0.29\n",
            "AMY for 3th sub: 0.48\n",
            "AMY for 4th sub: 0.17\n",
            "AMY for 5th sub: 0.19\n",
            "AMY for 6th sub: 0.39\n",
            "AMY for 7th sub: 0.13\n",
            "AMY for 8th sub: 0.54\n",
            "AMY for 9th sub: 0.19\n",
            "AMY for 10th sub: 0.09\n",
            "\n",
            "Cau for 1th sub: 0.17\n",
            "Cau for 2th sub: 0.54\n",
            "Cau for 3th sub: 0.18\n",
            "Cau for 4th sub: 0.09\n",
            "Cau for 5th sub: 0.33\n",
            "Cau for 6th sub: 0.08\n",
            "Cau for 7th sub: 0.06\n",
            "Cau for 8th sub: 0.24\n",
            "Cau for 9th sub: 0.42\n",
            "Cau for 10th sub: 0.31\n",
            "\n",
            "dlPFC for 1th sub: 0.24\n",
            "dlPFC for 2th sub: 0.23\n",
            "dlPFC for 3th sub: 0.27\n",
            "dlPFC for 4th sub: 0.28\n",
            "dlPFC for 5th sub: 0.26\n",
            "dlPFC for 6th sub: 0.09\n",
            "dlPFC for 7th sub: 0.22\n",
            "dlPFC for 8th sub: 0.08\n",
            "dlPFC for 9th sub: 0.33\n",
            "dlPFC for 10th sub: 0.26\n",
            "\n",
            "INS for 1th sub: 0.23\n",
            "INS for 2th sub: 0.73\n",
            "INS for 3th sub: 0.45\n",
            "INS for 4th sub: 0.48\n",
            "INS for 5th sub: 0.16\n",
            "INS for 6th sub: 0.47\n",
            "INS for 7th sub: 0.21\n",
            "INS for 8th sub: 0.47\n",
            "INS for 9th sub: 0.09\n",
            "INS for 10th sub: 0.4\n",
            "\n",
            "IPL for 1th sub: 0.41\n",
            "IPL for 2th sub: 0.21\n",
            "IPL for 3th sub: 0.43\n",
            "IPL for 4th sub: 0.44\n",
            "IPL for 5th sub: 0.31\n",
            "IPL for 6th sub: 0.24\n",
            "IPL for 7th sub: 0.41\n",
            "IPL for 8th sub: 0.52\n",
            "IPL for 9th sub: 0.29\n",
            "IPL for 10th sub: 0.3\n",
            "\n",
            "mCC for 1th sub: 0.18\n",
            "mCC for 2th sub: 0.1\n",
            "mCC for 3th sub: 0.28\n",
            "mCC for 4th sub: 0.07\n",
            "mCC for 5th sub: 0.19\n",
            "mCC for 6th sub: 0.7\n",
            "mCC for 7th sub: 0.09\n",
            "mCC for 8th sub: 0.27\n",
            "mCC for 9th sub: 0.09\n",
            "mCC for 10th sub: 0.19\n",
            "\n",
            "Nac for 1th sub: 0.24\n",
            "Nac for 2th sub: 0.4\n",
            "Nac for 3th sub: 0.28\n",
            "Nac for 4th sub: 0.26\n",
            "Nac for 5th sub: 0.35\n",
            "Nac for 6th sub: 0.13\n",
            "Nac for 7th sub: 0.17\n",
            "Nac for 8th sub: 0.29\n",
            "Nac for 9th sub: 0.75\n",
            "Nac for 10th sub: 0.25\n",
            "\n",
            "PCC for 1th sub: 0.2\n",
            "PCC for 2th sub: 0.33\n",
            "PCC for 3th sub: 0.39\n",
            "PCC for 4th sub: 0.22\n",
            "PCC for 5th sub: 0.14\n",
            "PCC for 6th sub: 0.52\n",
            "PCC for 7th sub: 0.2\n",
            "PCC for 8th sub: 0.48\n",
            "PCC for 9th sub: 0.14\n",
            "PCC for 10th sub: 0.3\n",
            "\n",
            "PCG for 1th sub: 0.21\n",
            "PCG for 2th sub: 0.28\n",
            "PCG for 3th sub: 0.12\n",
            "PCG for 4th sub: 0.09\n",
            "PCG for 5th sub: -0.11\n",
            "PCG for 6th sub: 0.29\n",
            "PCG for 7th sub: 0.27\n",
            "PCG for 8th sub: 0.24\n",
            "PCG for 9th sub: 0.29\n",
            "PCG for 10th sub: 0.43\n",
            "\n",
            "Prec for 1th sub: 0.35\n",
            "Prec for 2th sub: 0.36\n",
            "Prec for 3th sub: 0.49\n",
            "Prec for 4th sub: 0.37\n",
            "Prec for 5th sub: 0.21\n",
            "Prec for 6th sub: 0.49\n",
            "Prec for 7th sub: 0.4\n",
            "Prec for 8th sub: 0.57\n",
            "Prec for 9th sub: 0.32\n",
            "Prec for 10th sub: 0.41\n",
            "\n",
            "TP for 1th sub: 0.56\n",
            "TP for 2th sub: 0.27\n",
            "TP for 3th sub: 0.38\n",
            "TP for 4th sub: 0.37\n",
            "TP for 5th sub: 0.68\n",
            "TP for 6th sub: 0.3\n",
            "TP for 7th sub: 0.38\n",
            "TP for 8th sub: 0.72\n",
            "TP for 9th sub: 0.56\n",
            "TP for 10th sub: 0.62\n",
            "\n",
            "Put for 1th sub: 0.24\n",
            "Put for 2th sub: 0.11\n",
            "Put for 3th sub: 0.56\n",
            "Put for 4th sub: 0.03\n",
            "Put for 5th sub: 0.28\n",
            "Put for 6th sub: 0.21\n",
            "Put for 7th sub: 0.09\n",
            "Put for 8th sub: 0.4\n",
            "Put for 9th sub: 0.33\n",
            "Put for 10th sub: 0.12\n",
            "\n",
            "pSTS for 1th sub: 0.5\n",
            "pSTS for 2th sub: 0.43\n",
            "pSTS for 3th sub: 0.64\n",
            "pSTS for 4th sub: 0.44\n",
            "pSTS for 5th sub: 0.37\n",
            "pSTS for 6th sub: 0.55\n",
            "pSTS for 7th sub: 0.33\n",
            "pSTS for 8th sub: 0.6\n",
            "pSTS for 9th sub: 0.22\n",
            "pSTS for 10th sub: 0.38\n",
            "\n",
            "VC for 1th sub: 0.37\n",
            "VC for 2th sub: 0.17\n",
            "VC for 3th sub: 0.35\n",
            "VC for 4th sub: 0.31\n",
            "VC for 5th sub: 0.28\n",
            "VC for 6th sub: 0.25\n",
            "VC for 7th sub: 0.16\n",
            "VC for 8th sub: 0.4\n",
            "VC for 9th sub: 0.39\n",
            "VC for 10th sub: 0.32\n",
            "\n",
            "vlPFC for 1th sub: 0.32\n",
            "vlPFC for 2th sub: 0.17\n",
            "vlPFC for 3th sub: 0.52\n",
            "vlPFC for 4th sub: 0.38\n",
            "vlPFC for 5th sub: -0.03\n",
            "vlPFC for 6th sub: 0.25\n",
            "vlPFC for 7th sub: 0.27\n",
            "vlPFC for 8th sub: 0.39\n",
            "vlPFC for 9th sub: 0.5\n",
            "vlPFC for 10th sub: 0.25\n",
            "\n",
            "mOFC for 1th sub: 0.17\n",
            "mOFC for 2th sub: 0.29\n",
            "mOFC for 3th sub: 0.3\n",
            "mOFC for 4th sub: 0.58\n",
            "mOFC for 5th sub: 0.08\n",
            "mOFC for 6th sub: 0.46\n",
            "mOFC for 7th sub: 0.04\n",
            "mOFC for 8th sub: 0.65\n",
            "mOFC for 9th sub: 0.74\n",
            "mOFC for 10th sub: 0.22\n",
            "\n",
            "mPFC for 1th sub: 0.31\n",
            "mPFC for 2th sub: 0.04\n",
            "mPFC for 3th sub: 0.17\n",
            "mPFC for 4th sub: 0.38\n",
            "mPFC for 5th sub: 0.06\n",
            "mPFC for 6th sub: 0.11\n",
            "mPFC for 7th sub: 0.14\n",
            "mPFC for 8th sub: 0.75\n",
            "mPFC for 9th sub: 0.3\n",
            "mPFC for 10th sub: 0.22\n",
            "\n",
            "lOFC for 1th sub: 0.33\n",
            "lOFC for 2th sub: 0.22\n",
            "lOFC for 3th sub: 0.43\n",
            "lOFC for 4th sub: 0.72\n",
            "lOFC for 5th sub: 0.31\n",
            "lOFC for 6th sub: 0.14\n",
            "lOFC for 7th sub: 0.15\n",
            "lOFC for 8th sub: 0.57\n",
            "lOFC for 9th sub: 0.72\n",
            "lOFC for 10th sub: 0.18\n",
            "\n",
            "***Average across test subjects Correlation Coefficient between predicted and actual BOLD averaged across each Voxel Prediction values for ROIs***\n",
            "\n",
            "dmPFC: 0.26\n",
            "ACC: 0.23\n",
            "AMY: 0.27\n",
            "Cau: 0.24\n",
            "dlPFC: 0.23\n",
            "INS: 0.37\n",
            "IPL: 0.36\n",
            "mCC: 0.22\n",
            "Nac: 0.31\n",
            "PCC: 0.29\n",
            "PCG: 0.21\n",
            "Prec: 0.4\n",
            "TP: 0.48\n",
            "Put: 0.24\n",
            "pSTS: 0.45\n",
            "VC: 0.3\n",
            "vlPFC: 0.3\n",
            "mOFC: 0.35\n",
            "mPFC: 0.25\n",
            "lOFC: 0.38\n"
          ]
        }
      ],
      "source": [
        "print(\"***Each Test Subject's Correlation Coefficient between predicted and actual BOLD averaged across each Voxel Prediction values for ROIs***\")\n",
        "print()\n",
        "avg_r = list()\n",
        "for i in range(len(ROI_names)):\n",
        "  actual_test_data_output = test_data_unscaled[i][:,LOOK_AHEAD:,:]\n",
        "  pred_test_data_output = np.transpose(np.array([scalers[ROI_names[i]][j].inverse_transform(np.hstack([preds[i][:,:,j], preds[i][:,:LOOK_AHEAD,j]])) for j in range(len(scalers[ROI_names[i]]))]), (1,2,0))[:,:-LOOK_AHEAD,:] \n",
        "  for j in range(NUM_TEST_SUBS):\n",
        "    print(f\"{ROI_names[i]} for {j+1}th sub: {np.round(np.trace(np.corrcoef(actual_test_data_output[j,:,:], pred_test_data_output[j,:,:], rowvar=False)[:actual_test_data_output.shape[-1], actual_test_data_output.shape[-1]:])/actual_test_data_output.shape[-1], 2)}\")\n",
        "  print()\n",
        "\n",
        "print(\"***Average across test subjects Correlation Coefficient between predicted and actual BOLD averaged across each Voxel Prediction values for ROIs***\")\n",
        "print()\n",
        "for i in range(len(ROI_names)):\n",
        "  actual_test_data_output = test_data_unscaled[i][:,LOOK_AHEAD:,:]\n",
        "  pred_test_data_output = np.transpose(np.array([scalers[ROI_names[i]][j].inverse_transform(np.hstack([preds[i][:,:,j], preds[i][:,:LOOK_AHEAD,j]])) for j in range(len(scalers[ROI_names[i]]))]), (1,2,0))[:,:-LOOK_AHEAD,:]\n",
        "  sum_r = 0\n",
        "  for j in range(NUM_TEST_SUBS):\n",
        "    sum_r += np.trace(np.corrcoef(actual_test_data_output[j,:,:], pred_test_data_output[j,:,:], rowvar=False)[:actual_test_data_output.shape[-1], actual_test_data_output.shape[-1]:]/actual_test_data_output.shape[-1])\n",
        "  print(f\"{ROI_names[i]}: {np.round(sum_r / NUM_TEST_SUBS, 2)}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {
        "id": "f8gPew9YMI2B",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "75065992-4bab-4ff4-abdf-599b2d16d37d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "***Model's Final Scaled MSE(Train) Loss between predicted and actual all voxel BOLD values for ROIs for the Train Subjects***\n",
            "\n",
            "dmPFC: 0.01049\n",
            "ACC: 0.00837\n",
            "AMY: 0.00642\n",
            "Cau: 0.00824\n",
            "dlPFC: 0.01188\n",
            "INS: 0.00316\n",
            "IPL: 0.01621\n",
            "mCC: 0.00836\n",
            "Nac: 0.00472\n",
            "PCC: 0.00918\n",
            "PCG: 0.01838\n",
            "Prec: 0.00971\n",
            "TP: 0.00936\n",
            "Put: 0.0015\n",
            "pSTS: 0.00411\n",
            "VC: 0.02799\n",
            "vlPFC: 0.00878\n",
            "mOFC: 0.0124\n",
            "mPFC: 0.00903\n",
            "lOFC: 0.0104\n",
            "\n",
            "***Model's Final MSE(Validation) Loss between predicted and actual all voxel BOLD values for ROIs for the Test Subjects***\n",
            "\n",
            "dmPFC: 0.01088\n",
            "ACC: 0.01027\n",
            "AMY: 0.00566\n",
            "Cau: 0.01263\n",
            "dlPFC: 0.01285\n",
            "INS: 0.00263\n",
            "IPL: 0.02133\n",
            "mCC: 0.01131\n",
            "Nac: 0.00701\n",
            "PCC: 0.01572\n",
            "PCG: 0.02733\n",
            "Prec: 0.01158\n",
            "TP: 0.00647\n",
            "Put: 0.00145\n",
            "pSTS: 0.00475\n",
            "VC: 0.03019\n",
            "vlPFC: 0.00891\n",
            "mOFC: 0.01176\n",
            "mPFC: 0.01337\n",
            "lOFC: 0.01146\n"
          ]
        }
      ],
      "source": [
        "print(\"***Model's Final Scaled MSE(Train) Loss between predicted and actual all voxel 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[i].history['loss'][-1], 5))\n",
        "print()\n",
        "print(\"***Model's Final MSE(Validation) Loss between predicted and actual all voxel 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[i].history['val_loss'][-1], 5))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "metadata": {
        "id": "EQ3FUO9eY5gO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6013bd99-a9f5-4eeb-fcdc-555dcebf715e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "***Model's Final MSE(Validation) Loss between predicted and actual all voxel BOLD values for ROIs for the Test Subjects***\n",
            "\n",
            "dmPFC for Each Validation Subject: [ 66.78875   82.384766  34.20687   43.540997  59.08335  138.52043\n",
            "  36.266857  24.913141  65.12966   66.852615]\n",
            "dmPFC : 61.768745\n",
            "ACC for Each Validation Subject: [47.119473 20.853388 38.960106 23.500717 18.386934 60.79465  39.709282\n",
            " 41.52052  37.470722 17.836008]\n",
            "ACC : 34.61518\n",
            "AMY for Each Validation Subject: [41.373962 35.452267 35.228153 22.577192 22.41662  59.109333 29.02937\n",
            " 56.205154 75.12239  26.16963 ]\n",
            "AMY : 40.26841\n",
            "Cau for Each Validation Subject: [ 40.076714  37.215763  26.564562 180.97519   33.240337 177.61967\n",
            "  17.706318 123.43913   23.753912  38.960907]\n",
            "Cau : 69.955246\n",
            "dlPFC for Each Validation Subject: [38.154266 25.141165 25.637014 21.809124 45.775192 45.985985 37.407425\n",
            " 40.21276  31.013205 37.117577]\n",
            "dlPFC : 34.82537\n",
            "INS for Each Validation Subject: [10.035289   4.3607826  9.24881   10.122032   5.0312915  3.5727704\n",
            "  9.146609   9.072486  11.386748   5.196496 ]\n",
            "INS : 7.717332\n",
            "IPL for Each Validation Subject: [ 53.93763   25.47155   54.18721   87.5942    58.00211  139.7998\n",
            "  50.259163  53.58384   25.35378   42.950207]\n",
            "IPL : 59.11394\n",
            "mCC for Each Validation Subject: [ 36.4774    20.391981  41.395992  20.990372  24.664156 114.86293\n",
            "  32.165833  56.957134  27.882412  42.891792]\n",
            "mCC : 41.868004\n",
            "Nac for Each Validation Subject: [11.050937   6.408411  11.406598  81.26438   15.614721  53.561275\n",
            "  4.6542597 30.056337  11.835125   6.6566877]\n",
            "Nac : 23.250874\n",
            "PCC for Each Validation Subject: [139.84091   33.502903  17.978672  11.682846  19.158554  94.26065\n",
            "  26.84138   48.22327   28.099339  52.414043]\n",
            "PCC : 47.200256\n",
            "PCG for Each Validation Subject: [ 91.19371  125.73461   43.138718  88.7131    78.32343  219.38857\n",
            " 138.15782   66.55849  151.28252   94.4663  ]\n",
            "PCG : 109.695724\n",
            "Prec for Each Validation Subject: [ 52.45513   64.25244   21.144264  42.10436   22.037481 139.35599\n",
            "  60.29136   30.699514  33.395878  46.48716 ]\n",
            "Prec : 51.22236\n",
            "TP for Each Validation Subject: [15.204021 21.544518 22.93242  14.671696 45.436455 33.333393 26.275023\n",
            " 35.431393 29.7687   48.598274]\n",
            "TP : 29.31959\n",
            "Put for Each Validation Subject: [ 3.0489943  4.239897   4.9687977  5.066137   3.9107995 12.77278\n",
            "  5.5781245 12.95111    3.71838    8.803895 ]\n",
            "Put : 6.5058913\n",
            "pSTS for Each Validation Subject: [11.449043  8.510422 20.307386 22.379877 10.527522 13.059081  8.882803\n",
            " 22.700901  7.157947 58.168602]\n",
            "pSTS : 18.314358\n",
            "VC for Each Validation Subject: [220.33008   82.106346  60.024956  80.52953  340.59464  327.32962\n",
            "  99.117455  64.013504 116.27021   63.56375 ]\n",
            "VC : 145.38802\n",
            "vlPFC for Each Validation Subject: [33.403057 19.09162   7.820119 12.464906 47.470936 32.946716 34.513165\n",
            " 23.81215  27.67031  12.449193]\n",
            "vlPFC : 25.164217\n",
            "mOFC for Each Validation Subject: [16.507412 32.515884 42.243706 24.737425 79.969635 86.61794  29.032305\n",
            " 45.499607 57.89235  42.29834 ]\n",
            "mOFC : 45.731464\n",
            "mPFC for Each Validation Subject: [ 57.206295  82.02805  100.30986  132.35216   77.29937  312.081\n",
            "  64.120056  35.128586  85.007904  71.42311 ]\n",
            "mPFC : 101.69564\n",
            "lOFC for Each Validation Subject: [46.80561  56.937267 34.76021  42.411716 30.329689 29.716282 39.459255\n",
            " 17.211557 23.664125 39.36289 ]\n",
            "lOFC : 36.06586\n"
          ]
        }
      ],
      "source": [
        "print(\"***Model's Final MSE(Validation) Loss between predicted and actual all voxel BOLD values for ROIs for the Test Subjects***\")\n",
        "print()\n",
        "for i in range(len(ROI_names)):\n",
        "  actual_test_data_output = test_data_unscaled[i][:,LOOK_AHEAD:,:]\n",
        "  pred_test_data_output = np.transpose(np.array([scalers[ROI_names[i]][j].inverse_transform(np.hstack([preds[i][:,:,j], preds[i][:,:LOOK_AHEAD,j]])) for j in range(len(scalers[ROI_names[i]]))]), (1,2,0))[:,:-LOOK_AHEAD,:]\n",
        "  print(ROI_names[i]+\" for Each Validation Subject:\", np.mean(tf.keras.losses.mean_squared_error(actual_test_data_output, pred_test_data_output), axis=-1))\n",
        "  print(ROI_names[i]+\" :\", np.mean(np.mean(tf.keras.losses.mean_squared_error(actual_test_data_output, pred_test_data_output), axis=-1)))"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "vj_dqg--4sG6"
      },
      "execution_count": 36,
      "outputs": []
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "collapsed_sections": [],
      "name": "Basic-LSTM-Model-All-Voxel-4.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyOyf8P1/6QPUWOGNXgBKmio"
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}