battery-anomaly-detection/notebooks/simple_anomaly_detection.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simple Univariate Time Series Anomaly Detection"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## boilerplate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "\n",
    "import copy\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "from pylab import rcParams\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import rc\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import accuracy_score, confusion_matrix\n",
    "\n",
    "from torch import nn, optim\n",
    "\n",
    "import torch.nn.functional as F\n",
    "import random\n",
    "import datetime\n",
    "# from arff2pandas import a2p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x7f16083d1dd0>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# %matplotlib inline\n",
    "# %config InlineBackend.figure_format='retina'\n",
    "\n",
    "sns.set(style='whitegrid', palette='muted', font_scale=0.7)\n",
    "\n",
    "HAPPY_COLORS_PALETTE = [\"#01BEFE\", \"#FFDD00\", \"#FF7D00\", \"#FF006D\", \"#ADFF02\", \"#8F00FF\"]\n",
    "\n",
    "sns.set_palette(sns.color_palette(HAPPY_COLORS_PALETTE))\n",
    "\n",
    "# rcParams['figure.figsize'] = 12, 8\n",
    "\n",
    "RANDOM_SEED = 42\n",
    "np.random.seed(RANDOM_SEED)\n",
    "torch.manual_seed(RANDOM_SEED) \n",
    " \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import polars as pl\n",
    "from io import StringIO\n",
    "import math\n",
    "df = pl.read_csv('../data/battery_1.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We only need 'PACK1_CRIDATA_BATT_VOL'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## visualize fault and non-fault regions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "filter_condition =  df['PACK1_CRIDATA_BATT_VOL'].cast(pl.Float32) != 0\n",
    "voltage_data = (df['PACK1_CRIDATA_BATT_VOL']\n",
    "                .filter(filter_condition)\n",
    "                .cast(pl.Float32))\n",
    "\n",
    "def convert_values(values):\n",
    "    numerical_values = []\n",
    "    for value in values:\n",
    "        if value == 'False':\n",
    "            numerical_values.append(0)\n",
    "        elif value == 'True':\n",
    "            numerical_values.append(1)\n",
    "        else:\n",
    "            # numerical_values.append(np.nan)\n",
    "            numerical_values.append(-1)\n",
    "    return numerical_values\n",
    "\n",
    "\n",
    "fault_data = convert_values(df['BATT_PACK_1_FAULT']\n",
    "                            .filter(filter_condition))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'fault incidents')"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1000x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "fig, axs = plt.subplots(nrows=2, ncols=1, figsize=(10,3 * 2))\n",
    "\n",
    "axs[0].plot(voltage_data)\n",
    "axs[0].set_title(\"voltage\")\n",
    "axs[1].scatter(range(len(fault_data)), fault_data)\n",
    "axs[1].set_title(\"fault incidents\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Train region: 145000-end\n",
    "\n",
    "Test region: 45000-60000"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "train_voltage_data = voltage_data[145000:]\n",
    "test_voltage_data = voltage_data[85000:100000]\n",
    "val_voltage_data = voltage_data[120000:135000]\n",
    "fault_voltage_data = voltage_data[45000:60000]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_voltage_data = voltage_data[100000:]\n",
    "test_voltage_data = voltage_data[60000:85000]\n",
    "val_voltage_data = voltage_data[85000:100000]\n",
    "fault_voltage_data = voltage_data[0:60000]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'fault incidents')"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1000x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# fault region\n",
    "fig, axs = plt.subplots(nrows=2, ncols=1, figsize=(10,3 * 2))\n",
    "\n",
    "axs[0].plot(fault_voltage_data)\n",
    "axs[0].set_title(\"voltage\")\n",
    "fault_incidents = fault_data[0:60000]\n",
    "axs[1].scatter(range(len(fault_incidents)), fault_incidents)\n",
    "axs[1].set_title(\"fault incidents\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f151091b6d0>]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# test region\n",
    "plt.plot(test_voltage_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f15116719d0>]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# test region\n",
    "plt.plot(val_voltage_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f1511629cd0>]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiUAAAGcCAYAAAAGQNDLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAApEUlEQVR4nO3de3ST953n8c/ji7AMBAgQX0IYkgJpWmgaWkIIxSdcjNwkNGAa0m677BSSNEkznfFOG+aAmQ3dnNk06cC4p6ebbWHb7bS0XZg6mT2H2NChhck0NAWnIQkkXBpztbkUiDEyvsi//eMBWTbGSLb06Cfp/TqHg6TneaSfvs/t49/zk+QYY4wAAACSLCvZDQAAAJAIJQAAwBKEEgAAYAVCCQAAsAKhBAAAWIFQAgAArEAoAQAAVshJdgOi9eabb8oYo9zc3GQ3BQAARKm9vV2O4+iuu+667rwp01NijFGivufNGKO2traEPT+osVeoc+JRY29Q58TzqsaxnL9TpqfkSg/J5MmT4/7cwWBQ+/bt0/jx45Wfnx/35wc19gp1Tjxq7A3qnHhe1fjtt9+Oet6U6SkBAADpjVACAACsQCgBAABWIJQAAAArEEoAAIAVCCUAAMAKhBIAAGAFQgkAALACoQQAAFiBUAIAAKxAKAEAAFYglAAAACsQSgAAgBUIJUAEfiYdAJKHUIKM8laz0d8dMvqw4+rwsXSf0fid0sUQwaQ/6i64tb3QS20BIBqEEg89V2/0yDtGnTH8NW6M0bL3jL5xMDUO9OfbjQJ/NPo/Dfa11xiju/4gvXBE+ubBq6f/uFH64JK08ZT3beuv354zeqPJjlp/epdb25V/SnZLMkOIXr1+29Vk9Mppo7I/Gv1vC49VvfnlSaPSPxqdakuN9vYXocRDf/+BtPG09Otz0S9zqEX6UYO05qhiCjPJ8vwRaes56SvvdT12vNXoZFvy2iS5gWT67q77bzZfe97OxDcnLs60Gc3+o3TPbrsuO73VR20RH3+5z+jm/3D/CEh1+4NGf3PA6Hird+/l7t3SwnekLeekR9+7/vw2+OJe6d/OSX93KNktSSxCSRJcDEU/b+QxJxWuKjR1dL/f3GF0y++kj7zp1+LmO3QpSWf8ppD0xoWu+7svXHte2+r8L6eM3mm+ulGn27tu29Rmm9qSrn7SKJ1ql36eQr161/KpXdJ3j0m3/C5xr9Ha6faKvHgk9TfOyP0+HRFKPBL5l2wsB+1sp+t2Khzsc5zu96uOdd3+oNOv2vPJ2eRiqV2nRXXecd7o4XelT/zh6mm5EbX28I/MXnVEFC2GzB1Xxhj98YJRSyrsKHGSDgfwWP5I669fnHR7RZYfkk4ke2cZoHTfvB1jU79vH95++21J0uTJk+P+3CcvBDV+l08XlR2X5yvySQ2XL1fkOt17O3rjc6R4XSbMy1LSeiOiMTrH6HSHc/0ZByDHkWIZazk4O7YDY36WFIxjjbMdbw40YwdJR1rd28NzpPMdfc9/LYOypNbrvP+h2dKFZKUTSaNzpdW3Ss9+IP3TBOkLBV3bXGun0YtHpJeOS2c7et9fZg2XNt/pnvQHbU9cO4t80k8/5o7D2dkU3+cemSv9ud19D9mXj0ORx6be5u1p6lDpWKt7SfNal2Cz5E7/aL50rqP7fDdku72U02+Q6pqvv91EWjOuTTPPvqM77rhD+fn50S8oN6C+dEL6Y7M0e7jUHJIee//a81f+hfTc4a77X7hJ+sXlXqg5I9ztofKDq5ebOlT6xBBpbJ57zGnvlP4iT/qww71/pl0akSu1hKSLne6xae3RruXLbpRqzl7//YzOvXYPyZVzzES/dNdQ6dU/uzWXYju23Zjj7g/fuEV6YXx8j9GxnL8JJZKyfpMSJQDQT7/8uBvEPjlEKviP6Jb5+cekf26UNkdx0kBiTM/+UK+HhumLN0mfv8k9yc4aLuVm9X3SnPyG0bsXu+6/8BHpmTQfixFPnbOSF0py4vrKKSgVBo8CGJhH3o19mS/ujX87EJvXQ8MkuWNnIsfPDM42evpm6cGR0rQbpJyIkPLjhu6BRCKQpJKMDyVZjqPXJrXoM+/kJbspAIAITw06ru+33iyp+2XZiyHp20fcf5I0Z4Q74cgl6UBLMlqaPuLdSxKrjA8lkvTJwUYv+A+pZdRYBZ1cGbnXSduMO94j+/LOkON0Xf+/MsjQyL2el+u419GPtrrXZ6cMlWrPul3Gt+V1/4jskze711qH57jXOnMdKT9bmpgvDXKkTaellk7pziHS+hPS/ss7WeVfuNe/R+a61219We6gzKzLrx0y7rXdETnutcxzHW6b87K6riufv3wNfWyeOzaipVM62+4+hz9LKvS515bbjXv9N8eRTra776HNuK83NFv6MOS2NetyPbIcyRjp2frutb1lkPSXRdLepg79y1l3c/vWrV3jEpo6JP/lth8Iuh+ZlqTAjW5X+5X2X9lNWjrdddEpt62Nbe60m3Ld99tm3I9Rj851619/6drr/b+Nc587x5FWfdA1tuC/3uI+d1unu34lae9F6aODpWDIXVejc935j7W6bRrkSDOGSe8F3ef0ZUlHL0m5We71ZUfu6wzNdtuf5bjX9y+G3PsT8qUd59114DjSsGz3O1PWN3S196/HuPPmZUnDctyPmF+x+lZpSLZ0sbVd9SfPqGj0KP3Z5OpWv/SnFvd1B2dL9w6TfnvenXdwtvRBi9uW1k53nfgv1yNk3OvL+Vnue3Uc6dND3evs4/Lc5d8LuvPlZ7mPN14eS1Dsk350h/R2s3s9fX/Qfd4/XXLn7ZT0gxNd7ynY6V6LH5vXtQ3nOu7z5WW56+F0u7tdD8txa9vQ6rYhP9utrz/LvX0xJN0xWPrv9dIEv/QRv7sdzB8lPTBSOtHq7qNfLZa+vNc9gU0dKn18sFsDI+mfjl09xufTQ939p61TckynWlta1DnIr0HZ7lBTR267r5w4r2wn/svb7scHu7UY5LhjbYp87nX/vCzpiwXS8VbpuXp3u/vEEHf/a+90P2Fz5RNtjtxlG9u6xp+My5MevsmtVzDk7kutne5+OmaQVOBzxxHlZbnvqaVTmjzYHWvRaaSbB7nLHLnkrucLIXf5NiONynW3+4dGSe8H3feWm+VuT2fb3ePTiTb3GDkkW7o9X9rT7M5Tf8lt28WQe7y6IdsdU3GqzW3nkGx3mxozSFoWcWxcWnS5TVnSJ3ytKjhxUi988sbwmJJjl4yqz0j/70z3r1b4t16+ZuH7E6Wn9l97/4+0+lb3/6OXpBty3H0h13FrPz5fOtPmPn6s1V03/izpjSb3mPMZtzMnfEwoHuQ+Pi7P3b+G50rn2rv27aYOd5s/1eZuF8GQ+5z52V1jgDrl1ihL7jZ5tkP6n8fd1xkzSFpS6K6PS51d274xbo1zHXc/O9vhrpthOe44okud7nFgZK677s93SKGOdjWc/rM+VnSjgo5PjxZHV69EYkyJpGAwqH379vVrQFW0hu0w4YF/h6dLt+RFl0Zn1hn9x4fu7WQn2Gj0HJ/TMEMq8Dk63xzU/333qB7++C0aMSQxNe5LxQHT7ZNAP/qo9F+Kuuq58k9G/+PyQLf66dLYKNdPol2pZ7FPOjaje5uefN/of10+uV/ZNrzYlnvT1GE0/N/d2z/9mPSfCuyoX3888o4Jh+MrIve9ZNX4ig9ajD6y07399THSP01I3VpL3Y8Zsdb55yeNGtvcMPfv56WXTnRN65zl9Dpe8O/Gut+nFMn2Y+vZdqNRr7m3N02SykfHp71ebcuMKbFcLJuT3btK9HxZ0qdymjUoSZ9h7PkJqPw+Pmhl48cssy3fECxvXkwevqmrx+65W6X/XJjc9vQUWevcdCp8P3wxIvx+sUD6/u3ShQ6jIZf37zenSjs/dL8s8UrvnJOCNXOucTsdEUo80m2jSvetykI9Q0lfq+A6A/uTIpVCieVNva5Fo6Wdn5LuyJeG9vziHQtEHj8yPZT0JnKd3TnE0Z1DlDI/03EtmbSaCSUeiTyQZNIGZostPT7W2TN4RN61MQDY2KZI6RS0HcfR3TckuxXRybWxW89CE72
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "# train region\n",
    "# plt.plot(voltage_data[145000:])\n",
    "plt.plot(train_voltage_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(100774,)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_voltage_data.to_numpy().shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(25000,)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_voltage_data.to_numpy().shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = train_voltage_data.to_numpy()\n",
    "segment_size = 100\n",
    "segments = [ torch.tensor(data[i:i + segment_size]).unsqueeze(1).float() for i in range(0, len(data), segment_size) ]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "if (segments[-1].shape[0] != segment_size):\n",
    "    segments.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1007, 100, 1])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.stack(segments).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_dataset(series, segment_size, mean, stdev):\n",
    "    # normalize the data\n",
    "    data = (series.to_numpy() - mean)/stdev\n",
    "    segments = [ torch.tensor(data[i:i + segment_size]).unsqueeze(1).float() for i in range(0, len(data), segment_size) ]\n",
    "    # reject the last segment if it doesn't fit the shape\n",
    "    if (segments[-1].shape[0] != segment_size):\n",
    "        segments.pop()\n",
    "    n_seq, seq_len, n_features = torch.stack(segments).shape\n",
    "\n",
    "    return segments, seq_len, n_features\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = train_voltage_data.to_numpy()\n",
    "mean = np.mean(data)\n",
    "stdev = np.std(data)\n",
    "\n",
    "\n",
    "segment_size = 60\n",
    "train_dataset, seq_len, n_features = create_dataset(train_voltage_data, segment_size, mean, stdev)\n",
    "val_dataset, _, _ = create_dataset(val_voltage_data, segment_size, mean, stdev)\n",
    "test_normal_dataset, _, _ = create_dataset(test_voltage_data, segment_size, mean, stdev)\n",
    "test_anomaly_dataset, _, _ = create_dataset(fault_voltage_data, segment_size, mean, stdev)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Encoder Decoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Encoder(nn.Module):\n",
    "\n",
    "  def __init__(self, seq_len, n_features, embedding_dim=64):\n",
    "    super(Encoder, self).__init__()\n",
    "\n",
    "    self.seq_len, self.n_features = seq_len, n_features\n",
    "    self.embedding_dim, self.hidden_dim = embedding_dim, 2 * embedding_dim\n",
    "\n",
    "    self.rnn1 = nn.LSTM(\n",
    "      input_size=n_features,\n",
    "      hidden_size=self.hidden_dim,\n",
    "      num_layers=1,\n",
    "      batch_first=True\n",
    "    )\n",
    "    \n",
    "    self.rnn2 = nn.LSTM(\n",
    "      input_size=self.hidden_dim,\n",
    "      hidden_size=embedding_dim,\n",
    "      num_layers=1,\n",
    "      batch_first=True\n",
    "    )\n",
    "\n",
    "  def forward(self, x):\n",
    "    x = x.reshape((1, self.seq_len, self.n_features))\n",
    "\n",
    "    x, (_, _) = self.rnn1(x)\n",
    "    x, (hidden_n, _) = self.rnn2(x)\n",
    "\n",
    "    return hidden_n.reshape((self.n_features, self.embedding_dim))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Decoder(nn.Module):\n",
    "\n",
    "  def __init__(self, seq_len, input_dim=64, n_features=1):\n",
    "    super(Decoder, self).__init__()\n",
    "\n",
    "    self.seq_len, self.input_dim = seq_len, input_dim\n",
    "    self.hidden_dim, self.n_features = 2 * input_dim, n_features\n",
    "\n",
    "    self.rnn1 = nn.LSTM(\n",
    "      input_size=input_dim,\n",
    "      hidden_size=input_dim,\n",
    "      num_layers=1,\n",
    "      batch_first=True\n",
    "    )\n",
    "\n",
    "    self.rnn2 = nn.LSTM(\n",
    "      input_size=input_dim,\n",
    "      hidden_size=self.hidden_dim,\n",
    "      num_layers=1,\n",
    "      batch_first=True\n",
    "    )\n",
    "\n",
    "    self.output_layer = nn.Linear(self.hidden_dim, n_features)\n",
    "\n",
    "  def forward(self, x):\n",
    "    x = x.repeat(self.seq_len, self.n_features)\n",
    "    x = x.reshape((self.n_features, self.seq_len, self.input_dim))\n",
    "\n",
    "    x, (hidden_n, cell_n) = self.rnn1(x)\n",
    "    x, (hidden_n, cell_n) = self.rnn2(x)\n",
    "    x = x.reshape((self.seq_len, self.hidden_dim))\n",
    "\n",
    "    return self.output_layer(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RecurrentAutoencoder(nn.Module):\n",
    "\n",
    "  def __init__(self, seq_len, n_features, embedding_dim=64):\n",
    "    super(RecurrentAutoencoder, self).__init__()\n",
    "\n",
    "    self.encoder = Encoder(seq_len, n_features, embedding_dim).to(device)\n",
    "    self.decoder = Decoder(seq_len, embedding_dim, n_features).to(device)\n",
    "\n",
    "  def forward(self, x):\n",
    "    x = self.encoder(x)\n",
    "    x = self.decoder(x)\n",
    "\n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = RecurrentAutoencoder(seq_len, n_features, 128)\n",
    "model = model.to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_model(model, train_dataset, val_dataset, n_epochs):\n",
    "  optimizer = torch.optim.Adam(model.parameters(), lr=1e-5)\n",
    "  criterion = nn.L1Loss(reduction='sum').to(device)\n",
    "  history = dict(train=[], val=[])\n",
    "\n",
    "  best_model_wts = copy.deepcopy(model.state_dict())\n",
    "  best_loss = 10000.0\n",
    "  \n",
    "  for epoch in range(1, n_epochs + 1):\n",
    "    model = model.train()\n",
    "\n",
    "    train_losses = []\n",
    "    for seq_true in train_dataset:\n",
    "      optimizer.zero_grad()\n",
    "\n",
    "      seq_true = seq_true.to(device)\n",
    "      seq_pred = model(seq_true)\n",
    "\n",
    "      loss = criterion(seq_pred, seq_true)\n",
    "\n",
    "      loss.backward()\n",
    "      optimizer.step()\n",
    "\n",
    "      train_losses.append(loss.item())\n",
    "\n",
    "    val_losses = []\n",
    "    model = model.eval()\n",
    "    with torch.no_grad():\n",
    "      for seq_true in val_dataset:\n",
    "\n",
    "        seq_true = seq_true.to(device)\n",
    "        seq_pred = model(seq_true)\n",
    "\n",
    "        loss = criterion(seq_pred, seq_true)\n",
    "        val_losses.append(loss.item())\n",
    "\n",
    "    train_loss = np.mean(train_losses)\n",
    "    val_loss = np.mean(val_losses)\n",
    "\n",
    "    history['train'].append(train_loss)\n",
    "    history['val'].append(val_loss)\n",
    "\n",
    "    if val_loss < best_loss:\n",
    "      best_loss = val_loss\n",
    "      best_model_wts = copy.deepcopy(model.state_dict())\n",
    "\n",
    "    print(f'Epoch {epoch}: train loss {train_loss} val loss {val_loss}')\n",
    "\n",
    "  model.load_state_dict(best_model_wts)\n",
    "  return model.eval(), history"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1: train loss 7.188362143299209 val loss 10.97716400551796\n",
      "Epoch 2: train loss 7.061609009534848 val loss 10.861721575021743\n",
      "Epoch 3: train loss 7.050498445725213 val loss 10.759196199297905\n",
      "Epoch 4: train loss 6.953788480228296 val loss 10.529170639157295\n",
      "Epoch 5: train loss 6.819667443375704 val loss 10.165040640830993\n",
      "Epoch 6: train loss 6.738479136036151 val loss 9.992541402816773\n",
      "Epoch 7: train loss 6.614317140013353 val loss 9.791294813871383\n",
      "Epoch 8: train loss 6.452131601406606 val loss 9.845977551937104\n",
      "Epoch 9: train loss 6.408218298855107 val loss 9.518717983603478\n",
      "Epoch 10: train loss 6.238182526727458 val loss 9.489320818185806\n",
      "Epoch 11: train loss 6.234057898515033 val loss 9.289050007283688\n",
      "Epoch 12: train loss 6.202264721316195 val loss 9.33216683781147\n",
      "Epoch 13: train loss 6.1222286748257755 val loss 9.25562231683731\n",
      "Epoch 14: train loss 6.28904679132722 val loss 10.131250357687474\n",
      "Epoch 15: train loss 6.073458283509507 val loss 11.110596370041371\n",
      "Epoch 16: train loss 6.161009409070512 val loss 9.410741286337375\n",
      "Epoch 17: train loss 6.021980724913723 val loss 9.270162648320198\n",
      "Epoch 18: train loss 6.039738698001061 val loss 11.261745161175728\n",
      "Epoch 19: train loss 6.115699894411213 val loss 9.005485089600086\n",
      "Epoch 20: train loss 5.929479124247496 val loss 9.085405830562115\n",
      "Epoch 21: train loss 5.9451709336347704 val loss 10.106599816918374\n",
      "Epoch 22: train loss 5.924677521709248 val loss 9.108658552646636\n",
      "Epoch 23: train loss 5.908539707831785 val loss 8.512088710725308\n",
      "Epoch 24: train loss 5.818426139967793 val loss 9.660966635107995\n",
      "Epoch 25: train loss 5.953280821415979 val loss 8.881353223979474\n",
      "Epoch 26: train loss 5.762612802924465 val loss 8.796815033614635\n",
      "Epoch 27: train loss 6.0233771145752035 val loss 9.594733444035054\n",
      "Epoch 28: train loss 5.884460732465063 val loss 8.864278678059579\n",
      "Epoch 29: train loss 5.812006496509816 val loss 9.826941768109798\n",
      "Epoch 30: train loss 5.818772723404619 val loss 9.912757200181485\n",
      "Epoch 31: train loss 5.6362157306673275 val loss 9.99971356779337\n",
      "Epoch 32: train loss 5.646149147277506 val loss 10.41991896033287\n",
      "Epoch 33: train loss 5.785268129284996 val loss 9.180850823998451\n",
      "Epoch 34: train loss 5.6033936036066185 val loss 8.335838904500008\n",
      "Epoch 35: train loss 5.639638055348907 val loss 8.63649248892069\n",
      "Epoch 36: train loss 5.496804546314098 val loss 8.519725093007088\n",
      "Epoch 37: train loss 5.45866653725212 val loss 8.703529002845288\n",
      "Epoch 38: train loss 5.5987114275740755 val loss 7.895355988562107\n",
      "Epoch 39: train loss 5.397800835968839 val loss 8.712894497811794\n",
      "Epoch 40: train loss 5.615536484239427 val loss 9.162039269328117\n",
      "Epoch 41: train loss 5.468912153788235 val loss 8.45761411190033\n",
      "Epoch 42: train loss 5.371571399009675 val loss 7.897047997713089\n",
      "Epoch 43: train loss 5.266479222919346 val loss 7.756879223942756\n",
      "Epoch 44: train loss 5.268004156937551 val loss 7.302376929938793\n",
      "Epoch 45: train loss 5.267588082587811 val loss 9.525786200582981\n",
      "Epoch 46: train loss 5.373221474869966 val loss 7.77464767986536\n",
      "Epoch 47: train loss 5.32135811762273 val loss 8.563139500975609\n",
      "Epoch 48: train loss 5.412440207110692 val loss 7.822439022362232\n",
      "Epoch 49: train loss 5.406725116318149 val loss 7.7465962873101235\n",
      "Epoch 50: train loss 5.159115838695666 val loss 7.441654227137565\n",
      "Epoch 51: train loss 5.258179729568099 val loss 7.8189039084911345\n",
      "Epoch 52: train loss 5.251028409168931 val loss 7.743886261582374\n",
      "Epoch 53: train loss 5.242734800604854 val loss 7.365176262140274\n",
      "Epoch 54: train loss 5.16607915904282 val loss 8.90385246372223\n",
      "Epoch 55: train loss 5.2259016893338135 val loss 8.867705811679363\n",
      "Epoch 56: train loss 5.194666571919587 val loss 7.8739802262187\n",
      "Epoch 57: train loss 5.249035688970258 val loss 7.216172798454761\n",
      "Epoch 58: train loss 5.070800466896737 val loss 6.85274638992548\n",
      "Epoch 59: train loss 5.001781966748019 val loss 7.9121731922626495\n",
      "Epoch 60: train loss 5.1056873312374185 val loss 7.273398827493191\n",
      "Epoch 61: train loss 4.9760447693428445 val loss 7.714040239751339\n",
      "Epoch 62: train loss 5.0596290826797485 val loss 7.861135354578495\n",
      "Epoch 63: train loss 5.159216250112683 val loss 8.330905803859235\n",
      "Epoch 64: train loss 5.089301896732502 val loss 8.29973559910059\n",
      "Epoch 65: train loss 5.077050341283232 val loss 7.0275069693923\n",
      "Epoch 66: train loss 5.104413759262878 val loss 7.527150939106941\n",
      "Epoch 67: train loss 5.011002344894154 val loss 7.2104483036994935\n",
      "Epoch 68: train loss 5.031821377153834 val loss 7.462278498470783\n",
      "Epoch 69: train loss 4.93549394425606 val loss 7.092176900625229\n",
      "Epoch 70: train loss 4.902165090153798 val loss 7.506531097173691\n",
      "Epoch 71: train loss 5.044680127577813 val loss 8.029633438766002\n",
      "Epoch 72: train loss 5.078257953991061 val loss 7.620706166148186\n",
      "Epoch 73: train loss 5.02238962424341 val loss 7.4123868288993835\n",
      "Epoch 74: train loss 4.943703004306026 val loss 7.7856830370426175\n",
      "Epoch 75: train loss 5.058452894515122 val loss 7.487752008140087\n",
      "Epoch 76: train loss 4.983188311229369 val loss 6.923008233428002\n",
      "Epoch 77: train loss 4.91655006462474 val loss 7.989273576080799\n",
      "Epoch 78: train loss 5.02005114208878 val loss 7.763792626202107\n",
      "Epoch 79: train loss 5.119667072916329 val loss 7.779459906995297\n",
      "Epoch 80: train loss 4.815837256517206 val loss 6.943657228469848\n",
      "Epoch 81: train loss 4.94981735579097 val loss 8.068133530378342\n",
      "Epoch 82: train loss 4.966924919932637 val loss 7.317310967862606\n",
      "Epoch 83: train loss 4.9220759348634315 val loss 7.525299256563186\n",
      "Epoch 84: train loss 4.896259387266146 val loss 7.622523278236389\n",
      "Epoch 85: train loss 4.785323318562172 val loss 7.6916364338994025\n",
      "Epoch 86: train loss 4.898927788957376 val loss 7.980075287938118\n",
      "Epoch 87: train loss 4.846099264995195 val loss 7.757217339038849\n",
      "Epoch 88: train loss 4.897296259353884 val loss 7.217446682631969\n",
      "Epoch 89: train loss 4.8730314556085474 val loss 7.53286054366827\n",
      "Epoch 90: train loss 4.7620205258403665 val loss 8.212237065553666\n",
      "Epoch 91: train loss 4.7782756012951495 val loss 7.190876980245114\n",
      "Epoch 92: train loss 4.864514986617783 val loss 7.239515961110592\n",
      "Epoch 93: train loss 4.675690712807716 val loss 8.097305634975433\n",
      "Epoch 94: train loss 4.7876884221515885 val loss 6.623932673871517\n",
      "Epoch 95: train loss 4.722695211113884 val loss 7.503434510350227\n",
      "Epoch 96: train loss 4.745365573961938 val loss 7.175907820641995\n",
      "Epoch 97: train loss 4.659669167756538 val loss 7.756110722780227\n",
      "Epoch 98: train loss 4.662637394221146 val loss 6.194095297515393\n",
      "Epoch 99: train loss 4.6344790222781125 val loss 7.093573769330979\n",
      "Epoch 100: train loss 4.656862292254589 val loss 7.243564149618149\n"
     ]
    }
   ],
   "source": [
    "model, history = train_model(\n",
    "  model, \n",
    "  train_dataset, \n",
    "  val_dataset, \n",
    "  n_epochs=100\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'history' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[23], line 3\u001b[0m\n\u001b[1;32m      1\u001b[0m ax \u001b[39m=\u001b[39m plt\u001b[39m.\u001b[39mfigure()\u001b[39m.\u001b[39mgca()\n\u001b[0;32m----> 3\u001b[0m ax\u001b[39m.\u001b[39mplot(history[\u001b[39m'\u001b[39m\u001b[39mtrain\u001b[39m\u001b[39m'\u001b[39m])\n\u001b[1;32m      4\u001b[0m ax\u001b[39m.\u001b[39mplot(history[\u001b[39m'\u001b[39m\u001b[39mval\u001b[39m\u001b[39m'\u001b[39m])\n\u001b[1;32m      5\u001b[0m plt\u001b[39m.\u001b[39mylabel(\u001b[39m'\u001b[39m\u001b[39mLoss\u001b[39m\u001b[39m'\u001b[39m)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'history' is not defined"
     ]
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 427,
       "width": 572
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax = plt.figure().gca()\n",
    "\n",
    "ax.plot(history['train'])\n",
    "ax.plot(history['val'])\n",
    "plt.ylabel('Loss')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(['train', 'test'])\n",
    "plt.title('Loss over training epochs')\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Save the model\n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "date = datetime.date.today().strftime('%y-%m-%d')\n",
    "MODEL_PATH = f'model_save/model_{date}.pth'\n",
    "\n",
    "torch.save(model, MODEL_PATH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# reload the model\n",
    "model = torch.load('model_save/model_23-08-29_1647.pth')\n",
    "model = model.to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Check reconstruction error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(model, dataset):\n",
    "  predictions, losses = [], []\n",
    "  criterion = nn.L1Loss(reduction='sum').to(device)\n",
    "  with torch.no_grad():\n",
    "    model = model.eval()\n",
    "    for seq_true in dataset:\n",
    "      seq_true = seq_true.to(device)\n",
    "      seq_pred = model(seq_true)\n",
    "\n",
    "      loss = criterion(seq_pred, seq_true)\n",
    "\n",
    "      predictions.append(seq_pred.cpu().numpy().flatten())\n",
    "      losses.append(loss.item())\n",
    "  return predictions, losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "_, losses = predict(model, test_normal_dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: ylabel='Density'>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "_, losses = predict(model, train_dataset)\n",
    "plt.xlim(0, 50)\n",
    "sns.kdeplot(losses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: ylabel='Density'>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# _, losses = predict(model, train_dataset)\n",
    "_, losses = predict(model, test_normal_dataset)\n",
    "plt.xlim(0, 50)\n",
    "sns.kdeplot(losses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: ylabel='Density'>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# _, losses = predict(model, train_dataset)\n",
    "_, losses = predict(model, test_anomaly_dataset)\n",
    "plt.xlim(0, 1000)\n",
    "sns.kdeplot(losses)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute THRESHOLD with training set data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions, losses = predict(model, train_dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_array = np.array(losses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "stdev = np.std(loss_array)\n",
    "mean = np.mean(loss_array)\n",
    "THRESHOLD = mean + stdev * 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check on test_normal_dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of intervals exceeding 1 std dev loss: 33/416\n"
     ]
    }
   ],
   "source": [
    "_, losses = predict(model, test_normal_dataset)\n",
    "exceed_count = sum(l > THRESHOLD for l in losses)\n",
    "print(f'number of intervals exceeding 1 std dev loss: {exceed_count}/{len(test_normal_dataset)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check on test_anomaly_dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of intervals exceeding 1 std dev loss: 333/416\n"
     ]
    }
   ],
   "source": [
    "_, losses = predict(model, test_anomaly_dataset)\n",
    "exceed_count = sum(l > THRESHOLD for l in losses)\n",
    "print(f'number of intervals exceeding 1 std dev loss: {exceed_count}/{len(test_normal_dataset)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## plot construction error vs original"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_prediction(data, model, title, ax):\n",
    "    predictions, pred_losses = predict(model, [data])\n",
    "\n",
    "    ax.scatter(range(60), data, label='true')\n",
    "    ax.scatter(range(60), predictions[0], label='reconstructed')\n",
    "    ax.set_title(f'{title} (loss: {np.around(pred_losses[0], 2)})')\n",
    "    ax.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 2200x800 with 12 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(\n",
    "    nrows=2,\n",
    "    ncols=6,\n",
    "    sharey=True,\n",
    "    sharex=True,\n",
    "    figsize=(22, 8)\n",
    ")\n",
    "\n",
    "sample_size = 6\n",
    "sample_indices = random.sample(range(0,len(test_normal_dataset)), sample_size)\n",
    "\n",
    "sampled_test_normal_dataset = [test_normal_dataset[i] for i in sample_indices]\n",
    "sampled_test_anomaly_dataset = [test_anomaly_dataset[i] for i in sample_indices]\n",
    "\n",
    "for i, data in enumerate(sampled_test_normal_dataset):\n",
    "    plot_prediction(data, model, title='Normal', ax=axs[0, i])\n",
    "\n",
    "for i, data in enumerate(sampled_test_anomaly_dataset):\n",
    "    plot_prediction(data, model, title='Anomaly', ax=axs[1, i])\n",
    "\n",
    "fig.tight_layout();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Assess quality of prediction of flagged intervals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we want to identify the count of anomalies in each interval in the \"test_anomaly_dataset\"\n",
    "# range: 45000:60000\n",
    "start_point = 0\n",
    "end_point = 60000\n",
    "fault_segments = [ fault_data[start_point+seq_len * i:start_point + seq_len * i + seq_len] for i in range(len(test_anomaly_dataset)) ]\n",
    "# len(test_anomaly_dataset)\n",
    "anomaly_count_list = [ fault_segments[i].count(1) for i in range(len(fault_segments))]\n",
    "anomaly_flag_actual = [ count > 0 for count in anomaly_count_list ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "69"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# there are 50 - 100 minute segments where there is an anomaly\n",
    "sum(np.array(anomaly_count_list) > 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "_, losses = predict(model, test_anomaly_dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "anomaly_flag_prediction = [ l > THRESHOLD for l in losses ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "result_mat = confusion_matrix(anomaly_flag_actual, anomaly_flag_prediction)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[642 289]\n",
      " [ 25  44]]\n"
     ]
    }
   ],
   "source": [
    "print(result_mat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "642 289 25 44\n"
     ]
    }
   ],
   "source": [
    "tn, fp, fn, tp = result_mat.ravel()\n",
    "\n",
    "print(tn, fp, fn, tp)\n",
    "\n",
    "#                     actual negative actual positive \n",
    "# predicted negative: tn fp\n",
    "# predicted positive: fn tp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6895810955961332\n",
      "0.6376811594202898\n",
      "0.686\n"
     ]
    }
   ],
   "source": [
    "# accuracy of negatives\n",
    "specificity = tn / (tn + fp)\n",
    "print(specificity)\n",
    "\n",
    "# accuracy of positives\n",
    "sensitivity = tp / (tp + fn)\n",
    "print(sensitivity)\n",
    "\n",
    "\n",
    "overall_accuracy = (tn + tp) / (tn + fp + fn + tp)\n",
    "print(overall_accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "only 13.213213213213212 of flagged intervals are actual\n"
     ]
    }
   ],
   "source": [
    "print(f\"only {tp / (fp + tp) * 100} of flagged intervals are actual\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6376811594202898"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tp / (fn + tp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## plot regions of predicted anomalies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### juxtapose over anomalous region"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "_, losses = predict(model, test_anomaly_dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "anomaly_flag_prediction = [ l > THRESHOLD for l in losses ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_segments = []\n",
    "count = 0\n",
    "for i in anomaly_flag_prediction:\n",
    "    count = count + 1\n",
    "    x_segments.append([count*60, count*60 + 60])\n",
    "y_segments = [ [0,0] for i in x_segments]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# fault region\n",
    "# fig, axs = plt.subplots(nrows=2, ncols=1, figsize=(10,3 * 2))\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "fault_incidents = fault_data[0:60000]\n",
    "ax.scatter(range(len(fault_incidents)), fault_incidents)\n",
    "true_color =\"green\"\n",
    "false_color = \"red\"\n",
    "\n",
    "labels = anomaly_flag_prediction\n",
    "sequences = x_segments\n",
    "\n",
    "y_level = 0.5\n",
    "for i, (sequence, label) in enumerate(zip(sequences, labels)):\n",
    "    if label:\n",
    "        ax.plot((sequence[0],sequence[1]), (y_level,y_level), color=\"red\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### juxtapose over whole dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "_, losses = predict(model, train_dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "anomaly_flag_prediction = [ l > THRESHOLD for l in losses ]\n",
    "x_segments = []\n",
    "count = 0\n",
    "for i in anomaly_flag_prediction:\n",
    "    count = count + 1\n",
    "    x_segments.append([count*60, count*60 + 60])\n",
    "y_segments = [ [0,0] for i in x_segments]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# fault region\n",
    "# fig, axs = plt.subplots(nrows=2, ncols=1, figsize=(10,3 * 2))\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "fault_incidents = fault_data\n",
    "ax.scatter(range(len(fault_incidents)), fault_incidents)\n",
    "true_color =\"green\"\n",
    "false_color = \"red\"\n",
    "\n",
    "labels = anomaly_flag_prediction\n",
    "sequences = x_segments\n",
    "\n",
    "y_level = 0.5\n",
    "for i, (sequence, label) in enumerate(zip(sequences, labels)):\n",
    "    if label:\n",
    "        ax.plot((sequence[0],sequence[1]), (y_level,y_level), color=\"red\")\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.11.5"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}