notebook-pytorch.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "49f0ec4e-051d-4e5c-ab62-909956b67602",
   "metadata": {},
   "outputs": [],
   "source": [
    "# -*- coding: utf-8 -*-\n",
    "\"\"\"\n",
    "Created on Sat Oct 29 21:06:30 2022\n",
    "Modified on Mon Sept 9 by awb9691\n",
    "@author: ssb60\n",
    "@author: Abigail Broscius awb9691@rit.edu\n",
    "\"\"\"\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import keras\n",
    "from keras.callbacks import History\n",
    "from tensorflow import keras\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense\n",
    "from keras.layers import LSTM\n",
    "from keras.layers import SimpleRNN\n",
    "from keras.layers import Dropout\n",
    "from keras.layers import BatchNormalization\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "from sklearn.preprocessing import OrdinalEncoder\n",
    "import pandas as pd\n",
    "import tensorflow as tf\n",
    "import torch\n",
    "from torch import nn\n",
    "from torch.autograd import Variable\n",
    "from pathlib import Path\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "42c3ed08-4003-47c0-9cd5-ab0b8feba270",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CUDA version: 11.8\n",
      "GPU available? (pytorch): False\n"
     ]
    }
   ],
   "source": [
    "# Check for GPU architecture/compat\n",
    "print(\"CUDA version:\", torch.version.cuda)\n",
    "print(\"GPU available? (pytorch):\", torch.cuda.is_available())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "52f818f7-8d3f-47e8-9876-3935330b26c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load in data\n",
    "Time_series_X_train = torch.tensor(np.load(r'T_s_X_train.npy')[0:100], dtype=torch.float32)\n",
    "Time_series_Y_train = torch.tensor(np.load(r'T_s_Y_train_flattened.npy')[0:100], dtype=torch.float32)\n",
    "Time_series_X_test = torch.tensor(np.load(r'T_s_X_test.npy'), dtype=torch.float32)\n",
    "Time_series_Y_test = torch.tensor(np.load(r'T_s_Y_test_flattened.npy'), dtype=torch.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d1db5503-1fdb-463a-afdf-aa64aeee7909",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x train shape:\n",
      "torch.Size([100, 192, 120])\n",
      "y train shape:\n",
      "torch.Size([100, 2880])\n"
     ]
    }
   ],
   "source": [
    "# Check data shape\n",
    "print(\"x train shape:\")\n",
    "print(Time_series_X_train.shape)\n",
    "print(\"y train shape:\")\n",
    "print(Time_series_Y_train.shape)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "fad06b85-da2e-4a6a-97c3-7bb036932b12",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Directory 'path_testing' created\n"
     ]
    }
   ],
   "source": [
    "# Create File System for saving output\n",
    "\n",
    "# Parent Directories\n",
    "parent_dir = r\".\\Outputs_from_models\"\n",
    "directory = \"path_testing\"  # change\n",
    "path = os.path.join(parent_dir, directory)\n",
    "Path(path).mkdir(parents=True, exist_ok=True)\n",
    "print(\"Directory '% s' created\" % directory)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "2bf58463-2299-4aeb-a1bb-f3e4c5c6dd65",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Leaf directories\n",
    "pathT = path + \"\\\\Testing_data\"\n",
    "Path(pathT).mkdir(parents=True, exist_ok=True)\n",
    "pathM = path + \"\\\\Model\"\n",
    "Path(pathM).mkdir(parents=True, exist_ok=True)\n",
    "pathP = path + \"\\\\Plots\"\n",
    "Path(pathP).mkdir(parents=True, exist_ok=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "4edb3375-bd5b-409b-814d-3563f4edbecd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a class for model structure in torch\n",
    "class TorchModel(nn.Module):\n",
    "    def __init__(self, seq_len, input_size, num_layers):\n",
    "        super(TorchModel, self).__init__()\n",
    "        self.input_size = input_size\n",
    "        self.seq_length = seq_len\n",
    "        self.num_layers = num_layers\n",
    "\n",
    "        self.lstm_1 = nn.LSTM(input_size=input_size, hidden_size=1000, batch_first=True)\n",
    "        self.lstm_2 = nn.LSTM(input_size=1000, hidden_size=500, batch_first=True)\n",
    "        self.fc_1 = nn.Linear(500, 3000)\n",
    "        self.fc_2 = nn.Linear(3000, 1000)\n",
    "        self.fc_3 = nn.Linear(1000, 3000)\n",
    "        self.op_layer = nn.Linear(3000, 2880)\n",
    "\n",
    "        self.relu = nn.ReLU()\n",
    "        self.tanh = nn.Tanh()\n",
    "        self.sigmoid = nn.Sigmoid()\n",
    "\n",
    "    def forward(self, x):\n",
    "        # print(\"input shape:\", x.shape)\n",
    "        h_0 = Variable(torch.zeros(self.num_layers, x.shape[0], 1000))  # hidden state\n",
    "        c_0 = Variable(torch.zeros(self.num_layers, x.shape[0], 1000))  # internal state\n",
    "        h_1 = Variable(torch.zeros(self.num_layers, x.shape[0], 500))  # hidden state\n",
    "        c_1 = Variable(torch.zeros(self.num_layers, x.shape[0], 500))# internal state\n",
    "        # print(\"h0 shape:\", h_0.shape)\n",
    "        # print(\"c0 shape:\", c_0.shape)\n",
    "        # print(\"h1 shape:\", h_1.shape)\n",
    "        # print(\"c1 shape:\", c_1.shape)\n",
    "\n",
    "        # Propagate input through LSTM\n",
    "        output, (hn, cn) = self.lstm_1(x, (h_0, c_0))  # first lstm layer\n",
    "        output = self.sigmoid(output)\n",
    "        # print(\"LSTM1 output shape:\", output.shape)\n",
    "        # hn = hn.view(-1, 500)\n",
    "        out, (hn, cn) = self.lstm_2(output, (h_1, c_1))  # second lstm layer\n",
    "        out = self.tanh(out)\n",
    "        hn = hn.view(-1, 500)\n",
    "        out = self.relu(hn)\n",
    "        out = self.fc_1(out)  # first fc layer\n",
    "        # print(\"out shape 1FC:\", out.shape)\n",
    "        out = self.relu(out)\n",
    "        out = self.fc_2(out)  # second fc layer\n",
    "        # print(\"out shape 2FC:\", out.shape)\n",
    "        out = self.relu(out)\n",
    "        out = self.fc_3(out)  # third fc layer\n",
    "        # print(\"out shape 3FC:\", out.shape)\n",
    "        out = self.relu(out)\n",
    "        out = self.op_layer(out)  # O/P layer\n",
    "        # print(\"out shape OP:\", out.shape)\n",
    "        out = self.sigmoid(out)\n",
    "\n",
    "        return out\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "bc141da7-a1a4-4610-afa2-789b1e9fedf8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define model hyperparameters\n",
    "seq_len = Time_series_X_train.shape[1]  # number of timestamps in 1 sample\n",
    "input_size = Time_series_X_train.shape[2]  # number of features in 1 sample\n",
    "# 1 sample = num timestamps x num features(power lines)\n",
    "num_epochs = 4\n",
    "learning_rate = 0.001"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "9ba546ca-66d5-4533-91d8-1c25f3e5b800",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TorchModel(\n",
      "  (lstm_1): LSTM(120, 1000, batch_first=True)\n",
      "  (lstm_2): LSTM(1000, 500, batch_first=True)\n",
      "  (fc_1): Linear(in_features=500, out_features=3000, bias=True)\n",
      "  (fc_2): Linear(in_features=3000, out_features=1000, bias=True)\n",
      "  (fc_3): Linear(in_features=1000, out_features=3000, bias=True)\n",
      "  (op_layer): Linear(in_features=3000, out_features=2880, bias=True)\n",
      "  (relu): ReLU()\n",
      "  (tanh): Tanh()\n",
      "  (sigmoid): Sigmoid()\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "# Instantiate the model\n",
    "torchmodel = TorchModel(input_size=input_size, seq_len=seq_len, num_layers=1)\n",
    "print(torchmodel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "2d408a49-75e9-411c-99ca-507990e63855",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the loss function and optimizer\n",
    "criterion = torch.nn.MSELoss()  # mean squared error\n",
    "optimizer = torch.optim.Adam(torchmodel.parameters(),\n",
    "                             lr=learning_rate,\n",
    "                             betas=(0.9,0.99),\n",
    "                             eps=1e-07,\n",
    "                             )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "c832daa4-db8c-4e97-b0e8-c7bc1abc9299",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0, Train loss: 0.02135\n",
      "\t Test loss: 0.02360\n",
      "Epoch: 1, Train loss: 0.01970\n",
      "\t Test loss: 0.02148\n",
      "Epoch: 2, Train loss: 0.01799\n",
      "\t Test loss: 0.02167\n",
      "FINAL EPOCH\n",
      "Epoch: 3, Train loss: 0.01867\n",
      "\t Test loss: 0.02298\n"
     ]
    }
   ],
   "source": [
    "# Training!!\n",
    "train_loss_hist = []\n",
    "test_loss_hist = []\n",
    "predictions = 0\n",
    "for epoch in range(num_epochs):\n",
    "    # Train on the Training Set:\n",
    "    torchmodel.train()\n",
    "    outputs = torchmodel.forward(Time_series_X_train)  # forward pass\n",
    "    optimizer.zero_grad()  # calculate the gradient\n",
    "\n",
    "    # Loss Function\n",
    "    loss = criterion(outputs, Time_series_Y_train)\n",
    "    loss.backward()\n",
    "    train_loss_hist.append(loss.item())  # track loss history\n",
    "    optimizer.step()  # backpropagation\n",
    "\n",
    "    # Evaluate on the Test Set:\n",
    "    torchmodel.eval()\n",
    "    with torch.no_grad():\n",
    "        pred = torchmodel(Time_series_X_test)\n",
    "        test_loss = criterion(pred, Time_series_Y_test).item()\n",
    "        test_loss_hist.append(test_loss)\n",
    "        if (epoch + 1) == num_epochs:  # on last training epoch\n",
    "            # save testing predictions\n",
    "            print(\"FINAL EPOCH\")\n",
    "            predictions = pred\n",
    "            \n",
    "\n",
    "    print(\"Epoch: %d, Train loss: %1.5f\" % (epoch, loss.item()))\n",
    "    print(\"\\t Test loss: %1.5f\" % test_loss)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "75720f0b-2314-4823-8721-ae38ee25f836",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.08412639796733856, 0.07724989950656891, 0.035829879343509674, 0.05915457382798195]\n"
     ]
    }
   ],
   "source": [
    "print(train_loss_hist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "5c9d40d7-c6a8-44b3-88c8-bf37c4343b95",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0.1199, 0.2458, 0.4358,  ..., 0.3518, 0.3674, 0.3080],\n",
      "        [0.1199, 0.2458, 0.4358,  ..., 0.3518, 0.3674, 0.3080],\n",
      "        [0.1199, 0.2458, 0.4358,  ..., 0.3518, 0.3674, 0.3080],\n",
      "        ...,\n",
      "        [0.1199, 0.2458, 0.4358,  ..., 0.3518, 0.3674, 0.3080],\n",
      "        [0.1200, 0.2458, 0.4358,  ..., 0.3518, 0.3674, 0.3080],\n",
      "        [0.1200, 0.2458, 0.4358,  ..., 0.3519, 0.3674, 0.3080]])\n"
     ]
    }
   ],
   "source": [
    "print(predictions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a5bc5d08-9f59-4e02-b199-ca776ef7b832",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f8ba39ec-cfb6-4850-b365-8db219d54733",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "6634b8ec-81f3-4a2d-b954-72d9481c5399",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ".\\Outputs_from_models\\path_testing\\Plots\\loss.png\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(train_loss_hist)\n",
    "plt.plot(test_loss_hist)\n",
    "plt.title('model loss')\n",
    "plt.ylabel('loss')\n",
    "plt.xlabel('epoch')\n",
    "plt.legend(['train', 'test'], loc='upper left')\n",
    "\n",
    "plt.savefig(path+r'\\Plots'+r'\\loss.png')\n",
    "print(path+r'\\Plots'+r'\\loss.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "dc578218-bec3-41ea-9833-8d9b769ed9ac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  56. 1321.]\n",
      " [  56. 1322.]\n",
      " [  56. 1323.]\n",
      " ...\n",
      " [ 323. 7750.]\n",
      " [ 323. 7751.]\n",
      " [ 323. 7752.]]\n"
     ]
    }
   ],
   "source": [
    "predictions[predictions<=0.3333] = 0\n",
    "predictions[predictions > 0.3333]=1\n",
    "pred = predictions\n",
    "idx_y=np.load('y_test_idx.npy')\n",
    "print(idx_y)\n",
    "# [0:100]\n",
    "df=pd.DataFrame(pred)\n",
    "df.insert(loc=0,column='day',value=idx_y[:,0])\n",
    "#df.insert(loc=1,column='hour',value=idx_y[:,1])\n",
    "#df['hour']=idx_y[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "a920980b-02cf-4c1b-868d-724b409d3d94",
   "metadata": {},
   "outputs": [],
   "source": [
    "mask1 = df.duplicated(subset=['day'],keep = \"first\") # this line is to get the first occ.\n",
    "df2=df[~mask1]\n",
    "\n",
    "pred_0_hr =df2.to_numpy()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "bec153ae-8f63-446c-b917-cd85b0e6105c",
   "metadata": {},
   "outputs": [],
   "source": [
    "pred_0_hr_list =[]\n",
    "temp=[]\n",
    "counter_op=0\n",
    "for i in range (1,len(pred_0_hr)):\n",
    "    if ( pred_0_hr[i,0]-pred_0_hr[i-1,0])<2:\n",
    "        temp.append(pred_0_hr[i,:])\n",
    "        if i== len(pred_0_hr)-1:\n",
    "            temp_np=np.array(temp)\n",
    "            index_for_temp=2\n",
    "            new_temp_1=[]\n",
    "            for count_reshape_r in range (0,len(temp_np)):\n",
    "                new_temp=[]\n",
    "                new_temp.append(temp_np[count_reshape_r,0])\n",
    "                    \n",
    "                for count_reshape_c in range (1,temp_np.shape[1]):\n",
    "                    if ((count_reshape_c) % 120)==0 : \n",
    "                        new_temp.append(temp_np[count_reshape_r,count_reshape_c])\n",
    "                        new_temp_1.append(new_temp)\n",
    "                        new_temp=[]\n",
    "                        new_temp.append(temp_np[count_reshape_r,0])\n",
    "                        \n",
    "                    else: \n",
    "                        new_temp.append(temp_np[count_reshape_r,count_reshape_c])\n",
    "\n",
    "                           \n",
    "            new_temp_1=np.array(new_temp_1)\n",
    "            df_3=pd.DataFrame(new_temp_1)\n",
    "            file_name=path +r'\\Testing_data\\excel'+str(counter_op)+'.xlsx'\n",
    "            df_3.to_excel(file_name)\n",
    "    else:\n",
    "        temp_np=np.array(temp)\n",
    "        index_for_temp=2\n",
    "        new_temp_1=[]\n",
    "        for count_reshape_r in range (0,len(temp_np)):\n",
    "            new_temp=[]\n",
    "            new_temp.append(temp_np[count_reshape_r,0])\n",
    "                \n",
    "            for count_reshape_c in range (1,temp_np.shape[1]):\n",
    "                if ((count_reshape_c ) % 120)==0 : \n",
    "                    new_temp.append(temp_np[count_reshape_r,count_reshape_c])\n",
    "                    new_temp_1.append(new_temp)\n",
    "                    new_temp=[]\n",
    "                    new_temp.append(temp_np[count_reshape_r,0])\n",
    "                    \n",
    "                else: \n",
    "                    new_temp.append(temp_np[count_reshape_r,count_reshape_c])\n",
    "                    \n",
    "       \n",
    "        new_temp_1=np.array(new_temp_1)\n",
    "        df_3=pd.DataFrame(new_temp_1)\n",
    "        file_name=path+r'\\Testing_data\\excel'+str(counter_op)+'.xlsx'\n",
    "        df_3.to_excel(file_name)\n",
    "        temp=[]\n",
    "        counter_op=counter_op+1\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "224d23f3-bb2b-425b-89cc-d02a7fc67298",
   "metadata": {},
   "outputs": [],
   "source": [
    "#df.to_excel('out_33_10_xy_y_56.xlsx')\n",
    "np.save(path +r'\\output.npy',pred)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "728567ad-1bf1-4ded-90c0-6686a95d67e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "pred_t=pred\n",
    "np.save(path +r'\\output.npy',pred_t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "69081796-1160-4416-906a-9a4f69616301",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "288000\n",
      "trueval_pos\n",
      "141241\n",
      "trueval_neg\n",
      "146759\n",
      "positive_pred\n",
      "131600\n",
      "negative_pred\n",
      "156400\n"
     ]
    }
   ],
   "source": [
    "Time_series_Y_test[Time_series_Y_test<=0.33]=0\n",
    "Time_series_Y_test[Time_series_Y_test > 0.33]=1\n",
    "print(torch.numel(Time_series_Y_test))\n",
    "tp = np.count_nonzero(Time_series_Y_test == 1)\n",
    "tn = np.count_nonzero(Time_series_Y_test == 0)\n",
    "pp = np.count_nonzero(pred == 1)\n",
    "pn =np.count_nonzero(pred == 0)\n",
    "\n",
    "print('trueval_pos')\n",
    "print(tp)\n",
    "print('trueval_neg')\n",
    "print(tn)\n",
    "print('positive_pred')\n",
    "print(pp)\n",
    "print('negative_pred')\n",
    "print(pn)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "d698b395-545f-476e-a87c-94fd8cec17d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "total_positive=np.count_nonzero(Time_series_Y_test == 1)\n",
    "total_negative =np.count_nonzero(Time_series_Y_test == 0)\n",
    "pred_pos=np.count_nonzero(pred_t == 1)\n",
    "pred_neg =np.count_nonzero(pred_t == 0)\n",
    "\n",
    "mat_1 = Time_series_Y_test + pred_t\n",
    "tp = np.count_nonzero(mat_1 == 2)\n",
    "tp_arr=np.count_nonzero(mat_1 == 2,0)\n",
    "tn=np.count_nonzero(mat_1 == 0)\n",
    "tn_arr=np.count_nonzero(mat_1 == 0,0)\n",
    "\n",
    "mat_2 = Time_series_Y_test - pred_t\n",
    "fn = np.count_nonzero(mat_2 == 1)\n",
    "fn_arr=np.count_nonzero(mat_2 == 1,0)\n",
    "fp =np.count_nonzero(mat_2 ==-1)\n",
    "fp_arr=np.count_nonzero(mat_2 == -1,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "8aa85c0c-f3bf-44be-a3fb-8d379fa1cda4",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<>:13: SyntaxWarning: invalid escape sequence '\\c'\n",
      "<>:13: SyntaxWarning: invalid escape sequence '\\c'\n",
      "C:\\Users\\Abby\\AppData\\Local\\Temp\\ipykernel_17392\\3221100961.py:13: SyntaxWarning: invalid escape sequence '\\c'\n",
      "  file_name=path+'\\confusion_matrix.xlsx'\n"
     ]
    }
   ],
   "source": [
    "df_cm=pd.DataFrame(tp_arr.T)\n",
    "#df. rename(columns = {'old_col1':'new_col1', 'old_col2':'new_col2'}, inplace = True)\n",
    "df_cm.rename(columns={0:'True_Positive'},inplace='True')\n",
    "df_cm.insert(loc=1,column='True_Negative',value=tn_arr)\n",
    "df_cm.insert(loc=2,column='False_Positive',value=fp_arr)\n",
    "df_cm.insert(loc=3,column='False_Negative',value=fn_arr)\n",
    "lines =np.linspace(1, 120, num=120)\n",
    "lines_arr = np.tile(lines,24)\n",
    "df_cm.insert(loc=0,column='Line_No',value=lines_arr)\n",
    "hour=np.linspace(1, 24, num=24)\n",
    "hour_arr = np.repeat(hour,120)\n",
    "df_cm.insert(loc=1,column='Hour',value=hour_arr)\n",
    "file_name=path+'\\confusion_matrix.xlsx'\n",
    "df_cm.to_excel(file_name)\n",
    "df_false_neg = df_cm.groupby([\"Line_No\"]).False_Negative.sum().reset_index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "a6734986-d7f6-4fa7-bfd9-49ee0dea05cf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tp\n",
      "109255\n",
      "tn\n",
      "124414\n",
      "fp\n",
      "22345\n",
      "fn\n",
      "31986\n",
      "F1-score =  0.8008693708057073\n",
      "Most false neg line\n",
      "1960\n",
      "No of times\n",
      "88.0\n"
     ]
    }
   ],
   "source": [
    "print('tp')\n",
    "print(tp)\n",
    "print('tn')\n",
    "print(tn)\n",
    "print('fp')\n",
    "print(fp)\n",
    "print('fn')\n",
    "print(fn)\n",
    "\n",
    "f1_score = 2*tp/(2*tp + fp + fn)\n",
    "print('F1-score = ',f1_score)\n",
    "\n",
    "print('Most false neg line')\n",
    "print(df_false_neg.loc[df_false_neg.False_Negative.idxmax(),'False_Negative'])\n",
    "print(\"No of times\")\n",
    "print(df_false_neg.loc[df_false_neg.False_Negative.idxmax(),'Line_No'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c71d6c30-1fdc-4aa9-bcc1-cf62478c4a28",
   "metadata": {},
   "outputs": [],
   "source": [
    "LSTM_model.evaluate(Time_series_X_test,Time_series_Y_test)\n",
    "LSTM_model.evaluate(Time_series_X_train,Time_series_Y_train)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5732edc8-a52b-4c09-8cda-be16a15a05c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# saving model \n",
    "LSTM_model.save(path+'\\Model'+'\\LSTM_model.h5')\n",
    "np.save(path+'\\Model'+'\\my_history_LSTM_model.npy',history.history,allow_pickle=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "f4d6400b-c2c2-4856-977d-970686b1d3b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.53042661 0.67506733 0.5795726  ... 0.65828571 0.86439543 0.65578037]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<>:8: SyntaxWarning: invalid escape sequence '\\F'\n",
      "<>:15: SyntaxWarning: invalid escape sequence '\\F'\n",
      "<>:17: SyntaxWarning: invalid escape sequence '\\H'\n",
      "<>:22: SyntaxWarning: invalid escape sequence '\\H'\n",
      "<>:8: SyntaxWarning: invalid escape sequence '\\F'\n",
      "<>:15: SyntaxWarning: invalid escape sequence '\\F'\n",
      "<>:17: SyntaxWarning: invalid escape sequence '\\H'\n",
      "<>:22: SyntaxWarning: invalid escape sequence '\\H'\n",
      "C:\\Users\\Abby\\AppData\\Local\\Temp\\ipykernel_17392\\3526184465.py:8: SyntaxWarning: invalid escape sequence '\\F'\n",
      "  np.save(path+'\\False_Negative.npy',fn_per)\n",
      "C:\\Users\\Abby\\AppData\\Local\\Temp\\ipykernel_17392\\3526184465.py:15: SyntaxWarning: invalid escape sequence '\\F'\n",
      "  np.save(path+'\\False_Positive.npy',fp_per)\n",
      "C:\\Users\\Abby\\AppData\\Local\\Temp\\ipykernel_17392\\3526184465.py:17: SyntaxWarning: invalid escape sequence '\\H'\n",
      "  plt.savefig(path+r'\\Plots'+'\\Histogram_False_Positive.png')\n",
      "C:\\Users\\Abby\\AppData\\Local\\Temp\\ipykernel_17392\\3526184465.py:22: SyntaxWarning: invalid escape sequence '\\H'\n",
      "  plt.savefig(path+r'\\Plots'+'\\Histogram_Errors.png')\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Y_percentage_test = np.load('T_s_Y_test_flattened.npy')\n",
    "    \n",
    "indices = np.where(mat_2 == 1)\n",
    "\n",
    "print(Y_percentage_test[indices])\n",
    "fn_per=Y_percentage_test[indices]\n",
    "\n",
    "np.save(path+'\\False_Negative.npy',fn_per)\n",
    "plt.hist(fn_per)\n",
    "plt.savefig(path+r'\\Plots'+r'\\Histogram_False_Negative.png')\n",
    "plt.show() \n",
    "  \n",
    "indices = np.where(mat_2 == -1)\n",
    "fp_per=Y_percentage_test[indices]\n",
    "np.save(path+'\\False_Positive.npy',fp_per)\n",
    "plt.hist(fp_per)\n",
    "plt.savefig(path+r'\\Plots'+'\\Histogram_False_Positive.png')\n",
    "plt.show() \n",
    "\n",
    "Errors_true_false =np.append(fn_per,fp_per)\n",
    "plt.hist(Errors_true_false)\n",
    "plt.savefig(path+r'\\Plots'+'\\Histogram_Errors.png')\n",
    "plt.show() \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fe0a0f3a-33f6-47bb-9894-0661f5021dfa",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d7e8d721-d062-4191-aa8d-75ef86f2f82c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2adc1fbd-d901-4528-85f8-85f1f5d0d64b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "00b66a88-47ed-4bbc-8592-ef72c369c88d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "42689074-47b0-4283-8857-3e4be4342d90",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cb6e8101-f519-402f-a069-a2651426e97b",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.12.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}