6_Sensitivity.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "68359705",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "import torch.nn as nn\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e256fa5c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#loading data\n",
    "Non_MI_data = np.load('Non_MI_data.npy')\n",
    "Non_MI_label = np.load('Non_MI_label.npy')\n",
    "MI_data = np.load('MI_data.npy')\n",
    "MI_label = np.load('MI_label.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1292ada5",
   "metadata": {},
   "outputs": [],
   "source": [
    "#calculate average of Non-MI\n",
    "average_Non_MI = []\n",
    "for j in range(len(Non_MI_data[0])):\n",
    "    sum_value =0\n",
    "    for i in range(len(Non_MI_data)):\n",
    "        sum_value += Non_MI_data[i][j]\n",
    "    average_value = sum_value / len(Non_MI_data)\n",
    "    average_Non_MI.append(average_value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "4d2874f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "#calculate average of MI\n",
    "average_MI = []\n",
    "for j in range(len(MI_data[0])):\n",
    "    sum_value =0\n",
    "    for i in range(len(MI_data)):\n",
    "        sum_value += MI_data[i][j]\n",
    "    average_value = sum_value / len(MI_data)\n",
    "    average_MI.append(average_value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "86d64486",
   "metadata": {},
   "outputs": [],
   "source": [
    "#model struture reloading\n",
    "class DNN(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(DNN, self).__init__()\n",
    "        self.fc  = nn.Sequential(        \n",
    "            nn.Linear(382, 382//2),      \n",
    "            nn.ReLU(True),\n",
    "            nn.Linear(382//2,382//4),\n",
    "            nn.ReLU(True),\n",
    "            nn.Linear(382//4,382//8),\n",
    "        )\n",
    "        self.out = nn.Linear(382//8, 2) \n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.fc(x)\n",
    "        x = x.view(x.size(0), -1)           \n",
    "        output = self.out(x)\n",
    "        return output, x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "7be2fb20",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Miniconda\\lib\\site-packages\\ipykernel_launcher.py:36: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "c:\\Miniconda\\lib\\site-packages\\ipykernel_launcher.py:45: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "c:\\Miniconda\\lib\\site-packages\\ipykernel_launcher.py:64: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "c:\\Miniconda\\lib\\site-packages\\ipykernel_launcher.py:74: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n"
     ]
    }
   ],
   "source": [
    "#parameters\n",
    "EPOCH = 200\n",
    "BATCH_SIZE = 50\n",
    "TIME_STEP = 1\n",
    "INPUT_SIZE = 382\n",
    "LR = 0.001\n",
    "\n",
    "#replace each variables with average and feed into fully trained model to calculate the sensitivity changes \n",
    "sensitivity10 = []\n",
    "for num in range(5):\n",
    "    sen = []\n",
    "    Non_MI_data = np.load('Non_MI_data.npy')\n",
    "    Non_MI_label = np.load('Non_MI_label.npy')\n",
    "    MI_data = np.load('MI_data.npy')\n",
    "    MI_label = np.load('MI_label.npy')\n",
    "\n",
    "#calculate Non-MI average    \n",
    "    average_Non_MI = []\n",
    "    for j in range(len(Non_MI_data[0])):\n",
    "        sum_value =0\n",
    "        for i in range(len(Non_MI_data)):\n",
    "            sum_value += Non_MI_data[i][j]\n",
    "        \n",
    "        average_value = sum_value / len(Non_MI_data)\n",
    "        average_Non_MI.append(average_value)\n",
    "\n",
    "#calculate MI changes\n",
    "    average_MI = []\n",
    "    for j in range(len(MI_data[0])):\n",
    "        sum_value =0\n",
    "        for i in range(len(MI_data)):\n",
    "            sum_value += MI_data[i][j]\n",
    "        average_value = sum_value / len(MI_data)\n",
    "        average_MI.append(average_value)\n",
    "\n",
    "#loading model    \n",
    "    rnn = torch.load('dnnL_best_{}'.format(num)+'.pkl')\n",
    "    \n",
    "    sensitivity_Non_MI = []\n",
    "    Non_MI_data = torch.from_numpy(Non_MI_data)\n",
    "    Non_MI_data = torch.tensor(Non_MI_data, dtype=torch.float32)\n",
    "    Non_MI_data_re_standard = Non_MI_data.reshape(Non_MI_data.shape[0], TIME_STEP, INPUT_SIZE)\n",
    "    \n",
    "    Non_MI_data_out,last_layer = rnn(Non_MI_data_re_standard)\n",
    "    pred_Non_MI_standard = torch.max(Non_MI_data_out, 1)[0].data.squeeze().numpy().tolist()\n",
    "\n",
    "#calculate the Non-MI changes     \n",
    "    for i in range(len(average_Non_MI)):\n",
    "        Non_MI_data = np.load('Non_MI_data.npy')\n",
    "        Non_MI_data = torch.from_numpy(Non_MI_data)\n",
    "        Non_MI_data = torch.tensor(Non_MI_data, dtype=torch.float32)\n",
    "        \n",
    "        for j in range(len(Non_MI_data)):\n",
    "            Non_MI_data[j][i] = average_MI[i]    \n",
    "        Non_MI_data_re = Non_MI_data.reshape(Non_MI_data.shape[0], TIME_STEP, INPUT_SIZE)\n",
    "        Non_MI_data_out,last_layer = rnn(Non_MI_data_re)\n",
    "        pred_Non_MI = torch.max(Non_MI_data_out, 1)[0].data.squeeze().numpy().tolist()\n",
    "        divd_val = []\n",
    "        for b in range(len(pred_Non_MI)):\n",
    "            val = pred_Non_MI[b] - pred_Non_MI_standard[b]\n",
    "            divd_val.append(val)\n",
    "        sum_val = 0\n",
    "        \n",
    "        for a in divd_val:\n",
    "            sum_val += a\n",
    "        sensitivity_Non_MI.append(sum_val)\n",
    "    \n",
    "    sensitivity_MI = []\n",
    "    MI_data = torch.from_numpy(MI_data)\n",
    "    MI_data = torch.tensor(MI_data, dtype=torch.float32)\n",
    "    \n",
    "    MI_data_re_standard = MI_data.reshape(MI_data.shape[0], TIME_STEP, INPUT_SIZE)\n",
    "    MI_data_out,last_layer = rnn(MI_data_re_standard)\n",
    "    pred_MI_standard = torch.max(MI_data_out, 1)[0].data.squeeze().numpy().tolist()\n",
    "    \n",
    "#calculate the MI changes   \n",
    "    for i in range(len(average_MI)):\n",
    "        MI_data = np.load('MI_data.npy')\n",
    "        MI_data = torch.from_numpy(MI_data)\n",
    "        MI_data = torch.tensor(MI_data, dtype=torch.float32)\n",
    "\n",
    "        for j in range(len(MI_data)):\n",
    "            MI_data[j][i] = average_Non_MI[i]\n",
    "        \n",
    "        MI_data_re = MI_data.reshape(MI_data.shape[0], TIME_STEP, INPUT_SIZE)\n",
    "        MI_data_out,last_layer = rnn(MI_data_re)\n",
    "        pred_MI = torch.max(MI_data_out, 1)[0].data.squeeze().numpy().tolist()\n",
    "\n",
    "        divd_val = []\n",
    "        for b in range(len(pred_MI)):\n",
    "            val = pred_MI[b] - pred_MI_standard[b]\n",
    "            divd_val.append(val)\n",
    "\n",
    "        sum_val = 0\n",
    "        for a in divd_val:\n",
    "            sum_val += a\n",
    "        sensitivity_MI.append(sum_val)\n",
    "# combine MI sensitivity changes and Non-MI sensitivity changes   \n",
    "    sensitivity = []\n",
    "    for a in range(len(sensitivity_Non_MI)):\n",
    "        sensitivity.append(sensitivity_Non_MI[a] + sensitivity_MI[a])\n",
    "    \n",
    "    sensitivity10.append(sensitivity)\n",
    "    sen.append(sensitivity)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "7ff970f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "sen_numpy = np.array(sen)\n",
    "sen_numpy = np.sum(sen_numpy,axis=0)\n",
    "np.save('sensitivity_ave.npy',sen_numpy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "e9f18a45",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Select top 20 variables\n",
    "simi=[]\n",
    "simi_l = sen_numpy.tolist()\n",
    "for i in range(20):\n",
    "    simi.append(simi_l.index(min(simi_l)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f3496ee2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = []\n",
    "Total_simi = sen_numpy\n",
    "for i in range(len(Total_simi)):\n",
    "    x.append(i)\n",
    "y = Total_simi\n",
    "plt.scatter(x, y,s = 10,alpha = 0.5)\n",
    "\n",
    "y2 = []\n",
    "for i in simi:\n",
    "    y2.append(Total_simi[i])\n",
    "\n",
    "plt.scatter(simi, y2, c = 'red',alpha = 0.7) \n",
    "plt.xlabel('Data position')\n",
    "plt.ylabel('Sensitivity')\n",
    "plt.savefig('Sensitivity_final.tif', dpi = 400)\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "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.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}