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": 127,
   "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": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x7ff27834c5b0>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "%config InlineBackend.figure_format='retina'\n",
    "\n",
    "sns.set(style='whitegrid', palette='muted', font_scale=1.2)\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": 3,
   "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": 5,
   "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": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'fault incidents')"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1000x600 with 2 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 537,
       "width": 852
      }
     },
     "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": 89,
   "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": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'fault incidents')"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 1000x600 with 2 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 537,
       "width": 852
      }
     },
     "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[45000:60000]\n",
    "axs[1].scatter(range(len(fault_incidents)), fault_incidents)\n",
    "axs[1].set_title(\"fault incidents\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7ff17067c890>]"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 420,
       "width": 570
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# test region\n",
    "plt.plot(test_voltage_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7ff1704bb790>]"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 427,
       "width": 564
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# test region\n",
    "plt.plot(val_voltage_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7ff17059fc90>]"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 420,
       "width": 572
      }
     },
     "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": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(100774,)"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_voltage_data.to_numpy().shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(25000,)"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_voltage_data.to_numpy().shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "if (segments[-1].shape[0] != segment_size):\n",
    "    segments.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([557, 100, 1])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.stack(segments).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "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": 97,
   "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": 98,
   "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": 99,
   "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": 100,
   "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": 101,
   "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": 102,
   "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": 105,
   "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": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABIMAAAOsCAYAAADZVnaaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAB7CAAAewgFu0HU+AAEAAElEQVR4nOzdd5xTVfrH8W+SSaZXGIaOgFQFUbBgwQLIz67Y17KuqxQXFCvWVVx7V7CvrmJZCyrWVcCOoki30ZUmfZjek/z+iJPJvUlmkplkMjP5vF8vX+acnHvvmXAnM3nmOc+xuN1utwAAAAAAABAXrLGeAAAAAAAAAJoPwSAAAAAAAIA4QjAIAAAAAAAgjhAMAgAAAAAAiCMEgwAAAAAAAOIIwSAAAAAAAIA4QjAIAAAAAAAgjhAMAgAAAAAAiCMEgwAAAAAAAOIIwSAAAAAAAIA4QjAIAAAAAAAgjhAMAgAAAAAAiCMEgwAAAAAAAOIIwSAAAAAAAIA4QjAIAAAAAAAgjhAMAgAAAAAAiCMEgwAAAAAAAOIIwSAAAAAAAIA4QjAIAAAAAAAgjhAMAgAAgCSpX79+3v+uv/76WE9H06dPN8xp8+bNsZ4SENDbb79tuFe///77WE8JAOqVEOsJAABia/PmzRo5cqS33aVLF3322WcxnBEAAACAaCIzCAAAIAQXXHCB96/+xxxzTKynAwAA0GgEgwAAAAAAAOIIwSAAAAAAAIA4Qs0gAAAASJJWrVoV6ykYTJ48WZMnT471NAAAaHPIDAIAAAAAAIgjBIMAAAAAAADiCMvEAADNpqKiQosWLdLWrVu1Z88eJSYmql27dho4cKB69erVpHOvX79eK1eu1M6dO1VWViabzabU1FR17NhRe+21l3r16iWLxRLy+Vwul1avXq3Vq1crPz9fZWVlstvtSktLU+fOndWzZ0917969SXMORzRfu+aya9cuLVu2TDt37lRhYaHS09OVm5urYcOGKScnJ2LXcTqdWrp0qbZs2aKdO3dKkgYPHqyDDjooYteItMbMOT8/X6tXr9aGDRtUVFQkl8uljIwMdejQQfvvv39EX9PG+PHHH7V+/Xpt375dSUlJysvL00EHHaTs7OyYzKewsFCLFy/W1q1bVVpaquzsbPXr10+DBg0K673BrKqqSgsXLtSmTZtUXFysdu3aqWvXrho6dKgSEmL/q3bte+Pu3btVVlam7Oxsde7cWcOGDVNSUlLErrNnzx4tWbJE27ZtU2lpqXJzc9W/f38NGDCgyedujvc/p9Opn3/+Wb///rvy8/NVXl6u1NRUdenSRf3791eXLl2adP7y8nL98MMP2rp1qwoKCpSVlaXevXtryJAhjb5P8vPz9csvv2jjxo0qKSmR0+lUcnKy9x7s16+fUlJSmjRvAG1X7H9CAQDavN9++02PPPKIvvjiC1VUVAQc061bN1100UU655xzQv7FuLq6Wi+99JL++9//auPGjfWOTU9P1/Dhw3XOOefosMMOCzqutLRUzz77rN566y3t2LGj3nPm5OTo8MMP1wUXXKDBgweHNOdwRfK1mzp1qmbPnu1tv/vuu+rfv39Y83nggQf07LPPetv//ve/dcQRRwQd73a79b///U/PPfecfv75Z7ndbr8xFotFQ4cO1ZVXXqlhw4Y1OIfNmzdr5MiR3vakSZM0efJkVVZW6vHHH9fbb7/tDajUGjlyZKOCQW+//bZuuOEGv/4tW7aoX79+QY+bOXOmDj744IjP+aefftKHH36or7/+WmvWrKl37oMHD9a4ceM0evToesf58v2aTjvtNN1zzz1hj509e7aeeeYZrVu3zu8Yq9Wq4447Ttdee606derU4HymT5+uGTNmeNuffvqpunbtGtbYHTt26P7779cnn3yiyspKv+M6duyoK6+8UqeeemqD8/FVXl6uGTNm6PXXX1dxcbHf87m5ufrLX/6i8ePHy2az6frrr9c777zjfT6a9ZkqKir04osv6o033tDmzZsDjklMTNTo0aN15ZVXBn1NfZm/F2rv8Q0bNuiRRx7RvHnzVFVV5Xdcz549ddVVV+nYY48N++uI1s8OXxs2bNCTTz6pefPmBfx3rNWjRw/93//9n84999yQ7t1aJSUleuihh/Tuu++qpKTE7/msrCxNnDhRF1xwgWw2W0jn/OGHH/Tkk09qwYIFcrlcQcfZbDYNHDhQxx57rC6++OIWEZwE0HKwTAwAEFUvvviiTjrpJH388cdBf5mXpE2bNulf//qXTjvtNG3durXB8+bn5+uss87Svffe22AgSJKKi4s1Z84cvfLKK0HHbNiwQSeddJKefPLJBgNBtXN477339P777zc4tjEi/dqddtpphrZvYCgULpfL8LV26NBBhx56aNDxO3fu1Lnnnqsrr7xSP/30U8BAkOQJGC1atEjnnXee7rrrrqDj6rNlyxadeeaZevrpp/2CKi1VuHP+4YcfdPrpp+v5559vMBAkSStWrNCkSZN01VVX1Xv/REpVVZWuu+46TZ06NWAgSPLcQx9++KHOPPNMrV27NupzWrhwoU499VS99957AQNBkrRt2zZNnTpVd955Z8jn3bp1q0499VT9+9//DhpA2Llzpx599FFdfPHFKioqatT8G2PJkiUaPXq0HnrooaCBIEmqrKzUBx98oOOOO04ffPBBo661YMECnXrqqfroo48CBoIkT0Bn8uTJuummm+oNXJhF62dHLbfbrUceeUTHH3+83nnnnXoDQZLn58PTTz+t559/PuRrrF69WqeddppeeeWVgIEgSSooKNDdd9+tK6+8UjU1NQ2e8+GHH9b555+vb775psHX0+l06scff9SDDz6osrKykOcNID4QHgYARM0TTzyhRx991NBns9k0aNAgde7cWeXl5fr111+1bds27/OrV6/Wueeeq1dffVWdO3cOeF63261Jkybpl19+MfS3b99effv2VXZ2tiwWi0pKSrRx40Zt3LixwV+yKysrdemll2rLli2G/s6dO6t3797KzMyUy+VScXGxNmzYoE2bNjUqaBGqaLx2Bx98sLp06eL9Gt9//31de+21If81esGCBYbrnXzyyUGP3bhxoy666CK/17NDhw7q37+/MjIyVFJSop9//tkQCHnxxRdVWloa1gfzyspKTZo0yZtpkZiYqP3220+5ubkqLS1tlqBDuBozZ/MHP7vdrl69eqlTp05KS0tTdXW1duzYoVWrVhk++H344Ydyu916+OGHo/o13X777Xr33Xe9c9t3333VsWNH1dTUeJez1dq5c6euuOIKvfPOO3I4HFGZz7p163TVVVd5P4R37NhRAwYMUGpqqnbu3Klly5YZAkQzZ87Uvvvuq1NOOaXe8+bn5+vCCy/0C0Ln5uZq4MCBSktL0/bt27V8+XJVV1fru+++00033aTU1NTIf5Emn332maZMmWL4uiwWi3r16qUePXooJSVFu3fv1vLly733SFVVla655hrV1NSElR21fv163X///d7zZGVladCgQcrIyNDOnTu1dOlSVVdXe8fPmjVLNptNt99+e4PnjtbPjlpOp1NXXnmlPvnkE7/nevbsqR49eigtLU2lpaX6/fff9fvvv4f9fr9r1y5dd9113jnm5ORon332UWZmpgoKCrR06VKVlpZ6x3/yySd65plndNlllwU955tvvqmnnnrK0OdwODRgwAB17NhRiYmJKisr0+7du7VmzZqgASgAkAgGAQCi5LvvvtNjjz1m6Dv55JN13XXXKTc319vndrv16aefatq0ad5snK1bt+q6667TzJkzZbX6J7F++eWXWrx4sbfdo0cPTZs2TYccckjA2h9lZWX69ttv9eGHH8rpdAac76xZswwfVvfdd1/deuutQZd/FRUV6euvv9a7774bcI5NEa3XzmKx6JRTTtETTzwhyfNhZf78+TryyCNDmpc5k2js2LEBx1VVVWny5MmGQNCwYcN09dVX64ADDvAbP2/ePN1+++3avn27JM+/xcEHH6yTTz45pHm98sor3ppOkyZN0oUXXuhXJ8MclArVmDFjvEu1rrrqKi1fvlySlJeXp1d
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 470,
       "width": 577
      }
     },
     "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": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "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": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "# reload the model\n",
    "# model.torch.load('model.pth')\n",
    "# model = model.to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Check reconstruction error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "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": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[6.475390911102295,\n",
       " 4.057796478271484,\n",
       " 3.6951184272766113,\n",
       " 3.5229454040527344,\n",
       " 3.1105241775512695,\n",
       " 2.7158966064453125,\n",
       " 4.410896301269531,\n",
       " 3.1737751960754395,\n",
       " 5.078624725341797,\n",
       " 564.0125732421875,\n",
       " 118.96932983398438,\n",
       " 11.067346572875977,\n",
       " 7.681413650512695,\n",
       " 2.2629685401916504,\n",
       " 2.2459702491760254,\n",
       " 5.009679794311523,\n",
       " 3.5274581909179688,\n",
       " 4.4660749435424805,\n",
       " 4.193930625915527,\n",
       " 2.288841724395752,\n",
       " 5.305790424346924,\n",
       " 506.50933837890625,\n",
       " 170.89035034179688,\n",
       " 2.9803903102874756,\n",
       " 1.8732764720916748,\n",
       " 0.4762537479400635,\n",
       " 17.63483428955078,\n",
       " 13.621052742004395,\n",
       " 1.6280626058578491,\n",
       " 1.6280626058578491,\n",
       " 1.6280626058578491,\n",
       " 9.569190979003906,\n",
       " 3.950976610183716,\n",
       " 10.132783889770508,\n",
       " 4.41414213180542,\n",
       " 3.841397762298584,\n",
       " 14.235858917236328,\n",
       " 2.4932689666748047,\n",
       " 0.3788847029209137,\n",
       " 10.606548309326172,\n",
       " 2.6478137969970703,\n",
       " 3.971092700958252,\n",
       " 1.9757204055786133,\n",
       " 2.9639644622802734,\n",
       " 5.554292678833008,\n",
       " 2.3994808197021484,\n",
       " 9.777814865112305,\n",
       " 4.184451103210449,\n",
       " 3.016322135925293,\n",
       " 7.93351411819458,\n",
       " 3.2564563751220703,\n",
       " 7.106253623962402,\n",
       " 7.106253623962402,\n",
       " 7.106253623962402,\n",
       " 25.282350540161133,\n",
       " 5.763306617736816,\n",
       " 1.9292466640472412,\n",
       " 3.0547077655792236,\n",
       " 5.411063194274902,\n",
       " 2.4595675468444824,\n",
       " 2.9209418296813965,\n",
       " 5.213022232055664,\n",
       " 2.082340717315674,\n",
       " 5.661027908325195,\n",
       " 3.1858878135681152,\n",
       " 9.611069679260254,\n",
       " 3.48431396484375,\n",
       " 3.612818717956543,\n",
       " 3.256265163421631,\n",
       " 4.243818283081055,\n",
       " 3.121319055557251,\n",
       " 7.132509231567383,\n",
       " 2.606898307800293,\n",
       " 2.889389991760254,\n",
       " 5.744939804077148,\n",
       " 2.9277758598327637,\n",
       " 2.3206820487976074,\n",
       " 9.055814743041992,\n",
       " 2.2245290279388428,\n",
       " 5.559058666229248,\n",
       " 3.029712200164795,\n",
       " 2.92405366897583,\n",
       " 4.436098575592041,\n",
       " 2.8357269763946533,\n",
       " 3.2960450649261475,\n",
       " 3.0109457969665527,\n",
       " 8.913893699645996,\n",
       " 2.2014102935791016,\n",
       " 5.028566360473633,\n",
       " 4.177780628204346,\n",
       " 3.0008766651153564,\n",
       " 5.832966327667236,\n",
       " 3.4131276607513428,\n",
       " 3.6118223667144775,\n",
       " 3.449504852294922,\n",
       " 5.172828197479248,\n",
       " 4.8995442390441895,\n",
       " 3.3583712577819824,\n",
       " 3.749042510986328,\n",
       " 11.917932510375977]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_, losses = predict(model, test_normal_dataset)\n",
    "losses[:100]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: ylabel='Density'>"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 420,
       "width": 611
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "_, losses = predict(model, train_dataset)\n",
    "sns.kdeplot(losses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: ylabel='Density'>"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 420,
       "width": 602
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# _, losses = predict(model, train_dataset)\n",
    "_, losses = predict(model, test_normal_dataset)\n",
    "sns.kdeplot(losses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: ylabel='Density'>"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 420,
       "width": 630
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# _, losses = predict(model, train_dataset)\n",
    "_, losses = predict(model, test_anomaly_dataset)\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": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions, losses = predict(model, train_dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_array = np.array(losses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "stdev = np.std(loss_array)\n",
    "mean = np.mean(loss_array)\n",
    "THRESHOLD = mean + stdev "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check on test_normal_dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "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": 116,
   "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": 117,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_prediction(data, model, title, ax):\n",
    "    predictions, pred_losses = predict(model, [data])\n",
    "\n",
    "    ax.plot(data, label='true')\n",
    "    ax.plot(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": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 2200x800 with 12 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 777,
       "width": 2174
      }
     },
     "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": 119,
   "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": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "69"
      ]
     },
     "execution_count": 120,
     "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": 121,
   "metadata": {},
   "outputs": [],
   "source": [
    "_, losses = predict(model, test_anomaly_dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "anomaly_flag_prediction = [ l > THRESHOLD for l in losses ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[642, 289],\n",
       "       [ 25,  44]])"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "confusion_matrix(anomaly_flag_actual, anomaly_flag_prediction)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "68.60000000000001"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_score(anomaly_flag_actual, anomaly_flag_prediction) * 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}