battery-anomaly-detection/notebooks/multivar_anomaly_detection_overlap_window.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simple Univariate Time Series Anomaly Detection"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## boilerplate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "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 0x7fab3bf04c10>"
      ]
     },
     "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=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": 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": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "input_data = df.select(['PACK1_CRIDATA_AVG_CELL_TEMP', 'PACK1_CRIDATA_AVG_CELL_VOL', 'PACK1_CRIDATA_BATT_VOL', 'PACK1_CRIDATA_SOC'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# process explanatory variables\n",
    "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",
    "input_data = (df.select(\n",
    "    pl.col('PACK1_CRIDATA_AVG_CELL_TEMP').cast(pl.Float32), \n",
    "    pl.col('PACK1_CRIDATA_AVG_CELL_VOL').cast(pl.Float32),\n",
    "    pl.col('PACK1_CRIDATA_BATT_VOL').cast(pl.Float32),\n",
    "    pl.col('PACK1_CRIDATA_SOC').cast(pl.Float32),\n",
    "    pl.col('PACK1_CRIDATA_CURR').cast(pl.Float32))\n",
    ".filter(filter_condition))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [],
   "source": [
    "\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",
    "            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": 159,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'fault incidents')"
      ]
     },
     "execution_count": 159,
     "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": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_std = input_data.select(\n",
    "    ((pl.col('PACK1_CRIDATA_AVG_CELL_TEMP') - pl.col('PACK1_CRIDATA_AVG_CELL_TEMP').mean())/ pl.col('PACK1_CRIDATA_AVG_CELL_TEMP').std())\n",
    "    .alias('PACK1_CRIDATA_AVG_CELL_TEMP'),\n",
    "    ((pl.col('PACK1_CRIDATA_AVG_CELL_VOL') - pl.col('PACK1_CRIDATA_AVG_CELL_VOL').mean())/ pl.col('PACK1_CRIDATA_AVG_CELL_VOL').std())\n",
    "    .alias('PACK1_CRIDATA_AVG_CELL_VOL'),\n",
    "    ((pl.col('PACK1_CRIDATA_BATT_VOL') - pl.col('PACK1_CRIDATA_BATT_VOL').mean())/ pl.col('PACK1_CRIDATA_BATT_VOL').std())\n",
    "    .alias('PACK1_CRIDATA_BATT_VOL'),\n",
    "    ((pl.col('PACK1_CRIDATA_SOC') - pl.col('PACK1_CRIDATA_SOC').mean())/ pl.col('PACK1_CRIDATA_SOC').std())\n",
    "    .alias('PACK1_CRIDATA_SOC'),\n",
    "    ((pl.col('PACK1_CRIDATA_CURR') - pl.col('PACK1_CRIDATA_CURR').mean())/ pl.col('PACK1_CRIDATA_CURR').std())\n",
    "    .alias('PACK1_CRIDATA_CURR'),\n",
    "\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data = df_std[100000:]\n",
    "test_data = df_std[60000:85000]\n",
    "val_data = df_std[85000:100000]\n",
    "anomaly_data = df_std[0:60000]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(100774, 5)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_data.to_numpy().shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(25000, 5)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_data.to_numpy().shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_dataset(df, segment_size):\n",
    "    # normalize the data\n",
    "    data = df.to_numpy()\n",
    "    # sliding window\n",
    "    segments = [ torch.tensor(data[i:i + segment_size]).float() for i in range(0, len(data) - segment_size + 1, 10) ]\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": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "segment_size = 60\n",
    "train_dataset, seq_len, n_features = create_dataset(train_data, segment_size)\n",
    "val_dataset, _, _ = create_dataset(val_data, segment_size)\n",
    "test_normal_dataset, _, _ = create_dataset(test_data, segment_size)\n",
    "test_anomaly_dataset, _, _ = create_dataset(anomaly_data, segment_size)\n",
    "whole_dataset, _, _ = create_dataset(df_std, segment_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Encoder Decoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([60, 5])\n"
     ]
    }
   ],
   "source": [
    "x = val_dataset[0]\n",
    "print(x.shape)\n",
    "x = x.reshape((1, 60, 5))\n",
    "x.shape\n",
    "\n",
    "rnn_test_1 = nn.LSTM(  # 4\n",
    "      input_size=5,\n",
    "      # 64\n",
    "      hidden_size=64 * 2,\n",
    "      num_layers=1,\n",
    "      batch_first=True\n",
    ")\n",
    "\n",
    "rnn_test_2 = nn.LSTM(  # 4\n",
    "      input_size=64 * 2,\n",
    "      # 64\n",
    "      hidden_size=64,\n",
    "      num_layers=1,\n",
    "      batch_first=True\n",
    ")\n",
    "\n",
    "output, (_, _) = rnn_test_1(x)\n",
    "output, (hidden, _) = rnn_test_2(output)\n",
    "\n",
    "# output is [1, 60, 128]\n",
    "# hidden is [1, 1, 128]\n",
    "# we first expand [1, 60, 4] to [1, 60, 128]\n",
    "# then squeeze to [1, 1, 128]\n",
    "# effectively compressed time of 60 to 1 vector of size 128"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 1, 64])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hidden.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 60, 64])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = hidden\n",
    "x = x.repeat((1,60,1))\n",
    "x.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Encoder(nn.Module):\n",
    "\n",
    "  def __init__(self, seq_len, n_features, embedding_dim=64, num_layers=1):\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",
    "    self.num_layers = num_layers\n",
    "\n",
    "    self.rnn1 = nn.LSTM(\n",
    "      # 4\n",
    "      input_size=n_features,\n",
    "      # 64\n",
    "      hidden_size=self.hidden_dim,\n",
    "      num_layers=self.num_layers,\n",
    "      batch_first=True\n",
    "    )\n",
    "    \n",
    "    self.rnn2 = nn.LSTM(\n",
    "      # 64\n",
    "      input_size=self.hidden_dim,\n",
    "      # 128\n",
    "      hidden_size=embedding_dim,\n",
    "      num_layers=self.num_layers,\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",
    "    # hidden_n is 128 here\n",
    "    # but we only have 128 values\n",
    "\n",
    "    # return hidden_n.reshape((self.n_features, self.embedding_dim))\n",
    "    # hidden_n has same size as embedding_dim\n",
    "    return hidden_n.reshape(self.num_layers * self.embedding_dim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Decoder(nn.Module):\n",
    "\n",
    "  def __init__(self, seq_len, input_dim=64, n_features=1, num_layers=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",
    "    self.num_layers = num_layers\n",
    "\n",
    "    self.rnn1 = nn.LSTM(\n",
    "      # embedding_dim = 64\n",
    "      # input_dim = 64\n",
    "      input_size=num_layers * input_dim,\n",
    "      hidden_size=input_dim,\n",
    "      num_layers=self.num_layers,\n",
    "      batch_first=True\n",
    "    )\n",
    "\n",
    "    self.rnn2 = nn.LSTM(\n",
    "      # input_dim = 64\n",
    "      input_size=input_dim,\n",
    "      # hidden_size = 64 * 2\n",
    "      hidden_size=self.hidden_dim,\n",
    "      num_layers=self.num_layers,\n",
    "      batch_first=True\n",
    "    )\n",
    "\n",
    "    # input: hidden_dim = 2 * 64\n",
    "    # output: n_features = 4\n",
    "    self.output_layer = nn.Linear(self.hidden_dim, n_features)\n",
    "\n",
    "  def forward(self, x):\n",
    "    \n",
    "    # x = x.repeat(self.n_features, self.seq_len, 1)\n",
    "    # x = x.reshape((self.n_features, self.seq_len, self.input_dim))\n",
    "    x = x.repeat(1, self.seq_len, 1)\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": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RecurrentAutoencoder(nn.Module):\n",
    "\n",
    "  def __init__(self, seq_len, n_features, embedding_dim=64, num_layers=1):\n",
    "    super(RecurrentAutoencoder, self).__init__()\n",
    "\n",
    "    self.encoder = Encoder(seq_len, n_features, embedding_dim, num_layers).to(device)\n",
    "    self.decoder = Decoder(seq_len, embedding_dim, n_features, num_layers).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": 125,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = RecurrentAutoencoder(seq_len, n_features, embedding_dim=64, num_layers=1)\n",
    "model = model.to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_model(model, train_dataset, val_dataset, n_epochs):\n",
    "  optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)\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": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1: train loss 14.991484802913119 val loss 47.635426118142625\n",
      "Epoch 2: train loss 14.673848953528582 val loss 43.243409028579556\n",
      "Epoch 3: train loss 14.333927784033705 val loss 44.07000463096593\n",
      "Epoch 4: train loss 13.915726091935372 val loss 44.34826395232542\n",
      "Epoch 5: train loss 14.657572755171392 val loss 43.69780085126692\n",
      "Epoch 6: train loss 14.143000129734576 val loss 44.81571371340034\n",
      "Epoch 7: train loss 14.038070801698778 val loss 44.12152769414079\n",
      "Epoch 8: train loss 13.851427001248368 val loss 44.09310012995997\n",
      "Epoch 9: train loss 13.729247768691389 val loss 43.32384617272827\n",
      "Epoch 10: train loss 13.631058291626045 val loss 45.44009980039054\n",
      "Epoch 11: train loss 13.418263957398553 val loss 41.21652204711302\n",
      "Epoch 12: train loss 13.862140987962011 val loss 42.51774741463039\n",
      "Epoch 13: train loss 12.650342613859568 val loss 40.25015159753653\n",
      "Epoch 14: train loss 12.36933911645029 val loss 37.92169579183776\n",
      "Epoch 15: train loss 11.98887928614705 val loss 36.10202267464985\n",
      "Epoch 16: train loss 12.21290189172034 val loss 38.01268916975296\n",
      "Epoch 17: train loss 11.711113982606824 val loss 28.44262305868908\n",
      "Epoch 18: train loss 11.011346816528379 val loss 27.90213075880223\n",
      "Epoch 19: train loss 10.898415433791799 val loss 29.32146102943548\n",
      "Epoch 20: train loss 11.491236296296712 val loss 26.51003688107366\n",
      "Epoch 21: train loss 10.863789315553673 val loss 24.472279914565707\n",
      "Epoch 22: train loss 10.610268099098876 val loss 22.609055767250698\n",
      "Epoch 23: train loss 10.373339420433043 val loss 23.78191721941715\n",
      "Epoch 24: train loss 10.940695203234153 val loss 22.05775741749384\n",
      "Epoch 25: train loss 10.885960484635177 val loss 23.156156875776208\n",
      "Epoch 26: train loss 10.36299374574134 val loss 19.75051664094064\n",
      "Epoch 27: train loss 10.089229504392144 val loss 18.16691262698094\n",
      "Epoch 28: train loss 10.152652916431167 val loss 16.388314533233643\n",
      "Epoch 29: train loss 10.094028000273047 val loss 16.266330868583857\n",
      "Epoch 30: train loss 9.990942514965324 val loss 18.1360527489895\n",
      "Epoch 31: train loss 9.790299692248142 val loss 16.15177443210895\n",
      "Epoch 32: train loss 10.039502827225755 val loss 16.864113875775033\n",
      "Epoch 33: train loss 9.889029200513558 val loss 14.908555627188155\n",
      "Epoch 34: train loss 9.616837129562004 val loss 13.120580163049857\n",
      "Epoch 35: train loss 9.42455815551085 val loss 14.049857989760945\n",
      "Epoch 36: train loss 9.393890358449195 val loss 16.31934666091383\n",
      "Epoch 37: train loss 9.2998268636161 val loss 14.642723051042461\n",
      "Epoch 38: train loss 9.296024454156909 val loss 15.312676857945114\n",
      "Epoch 39: train loss 9.201674998250388 val loss 14.407547143470483\n",
      "Epoch 40: train loss 9.197074455388092 val loss 12.695137181808319\n",
      "Epoch 41: train loss 9.022051593624617 val loss 15.047900228436575\n",
      "Epoch 42: train loss 9.137689992548 val loss 14.91150041096984\n",
      "Epoch 43: train loss 8.931943488525517 val loss 12.387148332755302\n",
      "Epoch 44: train loss 8.874451617623743 val loss 14.627675122162172\n",
      "Epoch 45: train loss 9.200509475629904 val loss 13.392843184662503\n",
      "Epoch 46: train loss 9.126006494861354 val loss 13.105388391456476\n",
      "Epoch 47: train loss 8.900100591822547 val loss 13.178430976756042\n",
      "Epoch 48: train loss 9.019521129990737 val loss 12.107054019572344\n",
      "Epoch 49: train loss 8.804207691363546 val loss 13.318513815777756\n",
      "Epoch 50: train loss 8.858408954121746 val loss 12.733705319449255\n",
      "Epoch 51: train loss 8.688436110203641 val loss 15.280156064352463\n",
      "Epoch 52: train loss 8.092340259285344 val loss 18.562882003895815\n",
      "Epoch 53: train loss 7.582048114958774 val loss 15.711433462634135\n",
      "Epoch 54: train loss 7.539406633721346 val loss 17.022368440659946\n",
      "Epoch 55: train loss 7.081485559127491 val loss 12.375487418637228\n",
      "Epoch 56: train loss 7.130740252084515 val loss 13.577870465919725\n",
      "Epoch 57: train loss 6.972742149814952 val loss 13.01242988739524\n",
      "Epoch 58: train loss 6.974390369714212 val loss 12.156829171914321\n",
      "Epoch 59: train loss 6.755032019958942 val loss 13.100684676361722\n",
      "Epoch 60: train loss 6.97479202756636 val loss 12.936651795604158\n",
      "Epoch 61: train loss 6.606993020248079 val loss 13.80874253260252\n",
      "Epoch 62: train loss 6.520448666380317 val loss 13.02389475701246\n",
      "Epoch 63: train loss 6.444385555646042 val loss 11.342601695427527\n",
      "Epoch 64: train loss 6.519072658063532 val loss 12.230810649099956\n",
      "Epoch 65: train loss 6.548562949943498 val loss 12.799046216920068\n",
      "Epoch 66: train loss 6.350596522029143 val loss 12.202243250429031\n",
      "Epoch 67: train loss 6.298089423301209 val loss 12.522010730979435\n",
      "Epoch 68: train loss 6.234351575359069 val loss 12.915401603625371\n",
      "Epoch 69: train loss 6.223840727439007 val loss 11.906952536305456\n",
      "Epoch 70: train loss 6.2498281353994365 val loss 10.763029688337575\n",
      "Epoch 71: train loss 6.094569119391778 val loss 11.903022861400974\n",
      "Epoch 72: train loss 6.136690409408736 val loss 11.027987039766982\n",
      "Epoch 73: train loss 6.112186732917959 val loss 11.157776807941321\n",
      "Epoch 74: train loss 6.073190037388209 val loss 11.29262953538161\n",
      "Epoch 75: train loss 6.087775080543931 val loss 11.137414576138143\n",
      "Epoch 76: train loss 5.954031884364008 val loss 11.085648946219862\n",
      "Epoch 77: train loss 5.843934960049341 val loss 10.795274752358528\n",
      "Epoch 78: train loss 5.872989448278586 val loss 10.801579055339596\n",
      "Epoch 79: train loss 5.7880489398711275 val loss 11.505093461374774\n",
      "Epoch 80: train loss 5.737008810143939 val loss 10.853074759783155\n",
      "Epoch 81: train loss 5.613592992576669 val loss 10.640041053813437\n",
      "Epoch 82: train loss 5.395545467803132 val loss 10.255325305422014\n",
      "Epoch 83: train loss 5.473923093295339 val loss 9.33503757141107\n",
      "Epoch 84: train loss 5.4141714567417685 val loss 9.633902329744702\n",
      "Epoch 85: train loss 5.473207396916702 val loss 8.909583377040748\n",
      "Epoch 86: train loss 5.162455617662481 val loss 10.458845855320577\n",
      "Epoch 87: train loss 5.1817696539313784 val loss 9.489331444131093\n",
      "Epoch 88: train loss 5.0629925271562755 val loss 8.981164223135115\n",
      "Epoch 89: train loss 4.949556847366285 val loss 9.014035170612527\n",
      "Epoch 90: train loss 4.937979031550958 val loss 8.644254712197295\n",
      "Epoch 91: train loss 4.885893268939744 val loss 8.747803532120376\n",
      "Epoch 92: train loss 4.874019369166389 val loss 8.936452906586254\n",
      "Epoch 93: train loss 4.725279761567813 val loss 9.418706700873614\n",
      "Epoch 94: train loss 4.856170468588639 val loss 9.053455802110525\n",
      "Epoch 95: train loss 4.62928881468673 val loss 9.051609508568626\n",
      "Epoch 96: train loss 4.58303886756295 val loss 9.099835369818187\n",
      "Epoch 97: train loss 4.5736183714217 val loss 8.80084493558941\n",
      "Epoch 98: train loss 4.396421173492016 val loss 9.569508837537223\n",
      "Epoch 99: train loss 4.527437411227232 val loss 8.769417099569953\n",
      "Epoch 100: train loss 4.47397932656201 val loss 8.73031808185737\n"
     ]
    }
   ],
   "source": [
    "model, history = train_model(\n",
    "  model, \n",
    "  train_dataset, \n",
    "  val_dataset, \n",
    "  n_epochs=100\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "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": 129,
   "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": 223,
   "metadata": {},
   "outputs": [],
   "source": [
    "# reload the model\n",
    "model = torch.load('model_save/model_23-09-08.pth')\n",
    "model = model.to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Check reconstruction error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "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": 225,
   "metadata": {},
   "outputs": [],
   "source": [
    "_, losses = predict(model, test_normal_dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: ylabel='Density'>"
      ]
     },
     "execution_count": 226,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkQAAAGdCAYAAADzOWwgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA8ZUlEQVR4nO3de3yU5Z3///cdZoZMGCQnSKJ0IYVwEPBUtV37xcZDMu1WxUqbdtfKg/Wh2drdbbePINiqTegZmui6+/OHPbl9FK3tNoumWmti0Gr7bddqodUKQhwNqCQTgxGYJGQmmfv7x2TGhBzIJJO578m8no8HnWHmmjvX8FF597ru67oM0zRNAQAApLEMqzsAAABgNQIRAABIewQiAACQ9ghEAAAg7RGIAABA2iMQAQCAtEcgAgAAaY9ABAAA0p7D6g5Yae/evTJNU06n0+quAACACQqFQjIMQ+eff37CrmnJCJHP59P69evl9Xq1YcMGdXR0jGjT0dGhDRs2yOv1av369fL5fLH3Hn74YV199dVat26dPvOZzwx7Lx6macZ+wXqmaSoYDFIPG6AW9kEt7INa2Md0/N1tWHF0x2c/+1ndcMMN8nq9uv/++3XgwAFt27ZtWJstW7Zo+fLluvHGG9XY2KidO3fqgQceUHd3tz7ykY+oqalJubm5euCBB/SHP/xB9957b9z9eOmllxQMBrVy5UplZWUl6uthknp6erR//37qYQPUwj6ohX1QC/t48cUXZRiG1qxZk7BrJn2EqLOzUz6fT+Xl5ZKkiooKNTU1jWjX1NSkiooKSVJ5ebl8Pp+OHj2qcDgsSeru7pYknThxQgUFBUnqPQAAmImSfg9Re3u7ioqKZBiGJMnj8cjpdKqrq0s5OTmSpK6uLrlcLnk8HkmSYRgqLCxUW1ubVq9era997Wtat26dPB6P5s6dqwcffHBKfert7Z3al0JCROtAPaxHLeyDWtgHtbAP0zRjOSJRkh6IxpqhG/rFxmsTCAT005/+VL/85S+1cOFC7dy5U7fddpvuu+++SfeptbV10p9F4lEP+6AW9kEt7INa2IPL5Uro9ZIeiIqKitTe3h5Ld4FAQKFQSNnZ2bE2ubm5CgaDCgQC8ng8Mk1Tfr9fhYWF+t3vfqecnBwtXLhQknTttdeqrq5uSn1avHix3G73lK6Bqevt7VVrayv1sAFqYR/Uwj6ohX20tLQk/JpJD0T5+fkqLi5Wc3OzysrKVF9fr7KyshHtou9t3LhRzc3NKi4uVl5ens466yy99NJLOnbsmObNm6dnnnlGS5cunVKf3G43N8jZCPWwD2phH9TCPqiF9RI9XSZZtA9RTU2NtmzZotraWi1YsEC1tbXy+/2qrKxUQ0ODJKmqqkqbNm3SQw89pDlz5mj79u2SpDVr1uj666/XZz7zGTmdTs2ZM0ff+ta3rPgaAABghrAkEJWUlGjXrl0jXo+GIUkqKCjQzp07R/38zTffrJtvvnna+gcAANILR3cAAIC0RyACAABpj0AEAADSHoEIAACkPQIRAABIewQiAACQ9ghEAAAg7RGIEqStz9Sx/tHPYAMAAPZGIEqAd0Kmlj0n/Z89VvcEAABMBoEoAfaekLoHpJe7JX+QUSIAAFINgSgBXul57/lfAtb1AwAATA6BKAH2E4gAAEhpBKIEODAkEL1IIAIAIOUQiBKAKTMAAFIbgWiKjvebeqvvvd+/0iP1hbmxGgCAVEIgmqLodFmhS8pxSP2mtK/b2j4BAID4EIimKDpdtjJLOtcTec60GQAAqYVANEX7B0eDlmdJ5xCIAABISQ6rO5DqolNmK+dInlmR5wQiAABSC4FoiqJTZiuypDxn5PlfApJpmjIMw7qOAQCACWPKbApCYVMtvZHnK7Kks7OkWYbU1S+92Tf+ZwEAgH0QiKbgtZORVWVzZkkLZ0uZswytyIq8x7QZAACpg0A0Ba8M3lC9Ikux6bHzuLEaAICUQyCagv1D7h+Kiq404wgPAABSB4FoCg6MEojYiwgAgNRDIJqCV8YJRC29UvcAR3gAAJAKCESTZJpmbFPGFXPee73AZajAJZmS/sooEQAAKYFANEntQen4QOQPcKl7+HvnDgakPxOIAABICQSiSYpOly1xS7Mzhm/AyBEeAACkFgLRJI22wizqXFaaAQCQUghEk/TKkENdT3Xe3Mjji91S2OTGagAA7I5ANElDD3U91XK3NDtDCgxIr59Mbr8AAED8CESTNN6UmSPD0CqO8AAAIGUQiCbhRL8ZO7x1tEAkcWM1AACphEA0CQcHT7gvcEk5TmPUNtxYDQBA6iAQTcL+IYe6joUjPAAASB0EokmI7kE02gqzqGggaj0pvRtipRkAAHbmsOKH+nw+bd68WYFAQAUFBaqtrdWCBQuGteno6NCmTZvk9/vl8Xi0fft2LVmyRC+99JLuuOOOYe0uuOAC3XvvvUnrf2yF2TiBKMdp6H2zTb3RF1l+f2l2UroGAAAmwZIRourqalVWVqqxsVGlpaWqq6sb0aaurk6lpaVqbGxUZWWlqqurJUlr1qxRQ0ND7NeiRYv08Y9/PKn9n8iUmcS0GQAAqSLpI0SdnZ3y+XwqLy+XJFVUVGjt2rXatm3bsHZNTU268847JUnl5eWqqanR0aNHlZeXF2tz6NAh+Xw+XXHFFVPqU29v74Tb9ptSS2+mJEOLMk6qp2fs6bCzZzv0mJza826/enJDU+pjOojWIZ56YHpQC/ugFvZBLezDNE0ZxuiLmiYr6YGovb1dRUVFsS/i8XjkdDrV1dWlnJwcSVJXV5dcLpc8nsgQi2EYKiwsVFtb27BA9Mgjj+hjH/uYZs+ePaU+tba2Trjt4YHZCpmrlKkBnfDt0/5x6pEbypb0fv3xaJ/29x2YUh/TSTz1wPSiFvZBLeyDWtiDy+VK6PWSHojMMY6yGJr0JtqmoaFh1Om2eC1evFhut/v0DSW91pUhHZSWZxladfbKcds6Txq67S/S62aWSlaslCOxYXbG6e3tVWtra1z1wPSgFvZBLeyDWthHS0tLwq+Z9EBUVFSk9vb22HBXIBBQKBRSdnZ2rE1ubq6CwaACgYA8Ho9M05Tf71dhYWGszR//+Ec5nU6df/75U+6T2+1WVtZpbgga9PrbkbB2tifjtJ9Z7TY1Z5bUPWDoLbm1MotENBHx1APTi1rYB7WwD2phvURPl0kW3FSdn5+v4uJiNTc3S5Lq6+tVVlY2ol1ZWZnq6+slSc3NzSouLh4xXfaJT3wiOZ0eIrrkfsUoZ5idKsMwtGawHTdWAwBgX5asMqupqdGOHTvk9Xq1e/duVVVVye/3a926dbE2VVVV2r17t7xer3bs2KGtW7fG3uvt7dWTTz45rH2yvDLOGWaj4QgPAADsz5J9iEpKSrRr164Rrzc0NMSeFxQUaOfOnaN+3u1264UXXpi2/o3FNM24AxFL7wEAsD92qo5DR0h6tz/yh1YywfvpCEQAANgfgSgO0Q0Zi91S5qyJ3dAVvYeoLSi9HeQIDwAA7IhAFId4p8skaa7D0NLB0SRGiQAAsCcCURwmE4gkps0AALA7AlEcXpngGWaniq40e5FABACALRGI4sAIEQAAMxOBaIK6B0wd7os8n8imjENFA9H+HikY5sZqAADshkA0QQcGR4fmO6U8Z3xbhv/NbCnbIYXMSCgCAAD2QiCaoMlOl0mRM1fOGRxV+vOJxPUJAAAkBoFogqI3VC+f5Hl+HOEBAIB9EYgmKDpCtDLO+4eizmWlGQAAtkUgmqCpTJlJ0nlzI49/6Y6ciQYAAOyDQDQBA6apg1MMRKuypFmGdDQkHQkmrm8AAGDqCEQT8HqvFDSlzAxpUebkrpE5y9ByjvAAAMCWCEQTEJ0uW54lZRjxLbkfig0aAQCwJwLRBEz1/qEojvAAAMCeCEQTkKhAxAgRAAD2RCCagMke6nqqaCA62CP1DLDSDAAAuyAQnYZpmrHjNuI9w+xUha7I0R9hSX/tnnLXAABAghCITqMzJHX1S4akZe6pXcswDJ3HtBkAALZDIDqN6OjQ4kzJPWvyK8yiOMIDAAD7IRCdRqJuqI7iCA8AAOyHQHQasRuqp3j/UNTQQMQRHgAA2AOB6DQSPUK0IktyGdLxAan1ZGKuCQAApoZAdBqJDkTODENnD442cR8RAAD2QCAaR8+AqUODozgrExSIJDZoBADAbghE4zjYI5mS8pxSvmvqK8yiWGkGAIC9EIjGkejpsihGiAAAsBcC0TimOxC9flI63s9KMwAArEYgGsd0BaI8p6GFsyPP2Y8IAADrEYjGkahDXUfDtBkAAPZBIBrDgGnqYG/keaI2ZRyKG6sBALAPAtEYDp2UToal2RmRc8wSjSM8AACwDwLRGKL3Dy1zS7OMxC25j4oGope6I6NRAADAOgSiMUzn/UOStNQtuTOk3rD0au/0/AwAADAxBKIx7I+uMJuG+4ekyKjTmsFr//nE9PwMAAAwMQSiMRyYpiX3Q3FjNQAA9mBJIPL5fFq/fr28Xq82bNigjo6OEW06Ojq0YcMGeb1erV+/Xj6fL/beO++8oy984Qvyer366Ec/qp///OcJ7+N07UE01HlzI4/cWA0AgLUsCUTV1dWqrKxUY2OjSktLVVdXN6JNXV2dSktL1djYqMrKSlVXV8feu+2227R27Vo1Njbq17/+ta644oqE9q8zaKozFHm+fBoD0bnRU++7p+9nAACA03Mk+wd2dnbK5/OpvLxcklRRUaG1a9dq27Ztw9o1NTXpzjvvlCSVl5erpqZGR48e1fHjx3X48GF96lOfkiQZhqH8/Pwp9am3d/hdzX8+kSFptv7GFZb6+tQzpauPbeksSXLrrT7pjWM9ynNO0w9KEdE6nFoPJB+1sA9qYR/Uwj5M05SR4BXgSQ9E7e3tKioqin0Rj8cjp9Oprq4u5eTkSJK6urrkcrnk8URusjEMQ4WFhWpra1N7e7sWLFigLVu26MCBAzrrrLP05S9/WQsXLpx0n1pbW4f9/plgnqRFOnPghPbv9436mUQ5y1ilt8zZ+tUrb+giB3Nn0sh6wDrUwj6ohX1QC3twuVwJvV7SA5E5xp47Q5PeeG0GBga0Z88ePfjggzr33HP14IMP6stf/rJ27tw56T4tXrxYbrc79vufHHJI7dIH5s/RykUrJ33dibjgoENvdUnH8xdrZdHAtP4su+vt7VVra+uIeiD5qIV9UAv7oBb20dLSkvBrJj0QFRUVqb29PTbcFQgEFAqFlJ2dHWuTm5urYDCoQCAgj8cj0zTl9/tVWFiogYEBLVq0SOeee64kad26daqtrZ1Sn9xut7Ky3rtZyBeMBLLVZziUlTW981gXzDP1aJe0P+hSVlbiN4BMRafWA9ahFvZBLeyDWlgv0dNlkgU3Vefn56u4uFjNzc2SpPr6epWVlY1oV1ZWpvr6eklSc3OziouLlZeXp9WrV8swDB06dEiS9Oyzz2r58uUJ7WMyVphFccgrAADWS/oIkSTV1NRoy5Ytqq2t1YIFC1RbWyu/36/Kyko1NDRIkqqqqrRp0yY99NBDmjNnjrZv3y5JysjI0Ne//nV96UtfUn9/v+bNm6dvfetbCetb74Cp109Gnq+cpk0Zh4oGope7pWDYlCuDUSIAAJLNkkBUUlKiXbt2jXg9GoYkqaCgYMz7gs4///xRP58ILb2SKSnHIc1PwqqvxZnSGbOk4wORkanoZo0AACB52Kn6FEOny6ZjjvJUhmEwbQYAgMUIRKfYHz3UNQnTZVEc4QEAgLUIRKdIxhlmp4qOEHGEBwAA1iAQnSKZK8yihk6ZjbUHEwAAmD4EoiHCphkbIVqZxEC0ek6kEG+HpPZg8n4uAACIIBANcfik1BuWXEZk9VeyuGcZWjYYwLiPCACA5CMQDRGdLivJkhxJ3g+IlWYAAFiHQDTEfgumy6JYaQYAgHUIRENER4iWWxCIziMQAQBgGQLREAeiexBZEIiiU2YHeiLHhwAAgOQhEA0RnTJL5qaMUUUuKd8phRU51wwAACQPgWjQ0ZCpt0OR58vdyf/5HOEBAIB1CESDovsPvW+25HFYc+I8N1YDAGANAtGg/RbePxTFER4AAFiDQDToFQvvH4qKTZl1c4QHAADJRCAaZMWhrqdamSU5DelYv3S4z7p+AACQbghEg/bbIBC5MozYppB/PmFdPwAASDcEIkknw9LrvZHnVuxSPdR5cyOP3FgNAEDyEIgk+U4aCkua55AKXNb25ZzBe5heZC8iAACShkAk6UBvZJn9iqzIfkBWYi8iAACSj0Ak6eDJyB+D1dNl0nuByNcrnehnpRkAAMlAIJJ0cHCEyIpDXU+V7zJ05uC03UtMmwEAkBQEIkkHeyN/DFauMBuKaTMAAJIr7QORaUoHT0ZGiFZauCnjUBzhAQBAcqV9IBqQ1BM25DSk4kyrexPBER4AACRX2geifkVGh5a6JWeGtSvMooYGogGO8AAAYNoRiGSv6TJJWpYluTOknnBktRkAAJheBCLTPivMomYZhlYPBjTuIwIAYPqlfSAK6b1NGe2EG6sBAEietA9EsSkzmwUibqwGACB50j4QhWW/KTOJvYgAAEimtA9EknSm09Rchz1WmEVFp8ze6JPeCbHSDACA6UQgkrTcHba6CyPMcxhaPLgvEtNmAABMLwKRpGVue47AMG0GAEByEIgkLcu03wiRRCACACBZCERihAgAgHTnsOKH+nw+bd68WYFAQAUFBaqtrdWCBQuGteno6NCmTZvk9/vl8Xi0fft2LVmyRJK0fPlyrVixItb2xz/+sXJycibdnxU2vIdIei8QvdwthcKmbY4WAQBgprFkhKi6ulqVlZVqbGxUaWmp6urqRrSpq6tTaWmpGhsbVVlZqerq6mHv/8///I8aGhrU0NAwpTBkSCp0Tvrj02pxpjR3lhQ0pQM9VvcGAICZK+mBqLOzUz6fT+Xl5ZKkiooKNTU1jWjX1NSkiooKSVJ5ebl8Pp+OHj2a8P44ZMqw6cBLhmGwYzUAAEmQ9Cmz9vZ2FRUVyRhMIR6PR06nU11dXbGRnq6uLrlcLnk8kTRgGIYKCwvV1tamvLw8SdKnP/1phcNhffzjH9dNN9006f44Zaq3174nqJ4926n/K4f+9G5Inzij3+ruTKtoHexcj3RBLeyDWtgHtbAP0zRjOSJRkh6ITHP0G5iHfrHTtXnmmWdUWFioo0eP6pZbblF+fr6uvfbaSfXHYZhqbW2d1GeTIT+YJ2mR/rejV/u7X7W6O0lh53qkG2phH9TCPqiFPbhcroReL+mBqKioSO3t7bF0FwgEFAqFlJ2dHWuTm5urYDCoQCAgj8cj0zTl9/tVWFgoSbHHvLw8XXPNNdq7d+/kA5HCWrx4sdxu91S/2rQoDxj69svSaxlztXLlSqu7M616e3vV2tpq63qkC2phH9TCPqiFfbS0tCT8mkkPRPn5+SouLlZzc7PKyspUX1+vsrKyEe2i723cuFHNzc0qLi5WXl6ejh07pszMTM2ePVsnT57UU089pSuvvHLS/XHIlNvtVlaWzQ4zG3ThbFOGpI6QoeOz3CqcbdMbnhLIzvVIN9TCPqiFfVAL6yV6ukyyaJVZTU2NduzYIa/Xq927d6uqqkp+v1/r1q2LtamqqtLu3bvl9Xq1Y8cObd26VZL02muv6ZOf/KSuueYaXXfddVq+fLk+/elPT7ovluw7EIc5swwtG/z3jhurAQCYHpbkgZKSEu3atWvE6w0NDbHnBQUF2rlz54g2559/vh599NGE9cWuK8yGOtcTWXb/l4DkzbO6NwAAzDzsVJ0CzpkTeXyx29p+AAAwUxGIUgBHeAAAML0IRCkgGohe6ZFODtjz3DUAAFIZgSgFnDVbynVIA6a0jyM8AABIOAJRCjAMg2kzAACmEYEoRXCmGQAA04dAlCKiI0QvEogAAEg4AlGKOG8wEP05MPZZbwAAYHIIRCli5RzJYUjv9ktv9lndGwAAZhYCUYqYnWFo2eBZgi+zQSMAAAlFIEohqwenzf5KIAIAIKEIRCnk7MFDXvcRiAAASCgCUQphhAgAgOlBIEohqwYPed3XLYVZaQYAQMIQiFLIkkxpdobUE5ZaT1rdGwAAZg4CUQpxZBhaMXgfEdNmAAAkDoEoxawenDZj6T0AAIlDIEoxqwhEAAAkHIEoxRCIAABIPAJRiolOme3vlvrDrDQDACAR4g5EfX0cpGWlRZlSVoYUNKVXe63uDQAAM0PcgeiSSy7R5s2b9dvf/lbhcHg6+oRxZBgG02YAACRY3IHoscce07Jly3TXXXdp7dq1+vrXv64///nP09A1jCUaiFh6DwBAYjji/UBRUZFuuukm3XTTTXrttdf0q1/9SrfeeqtM09RVV12l9evX633ve9909BWDhu5YDQAApm7SN1X39/fr0KFDam1t1bFjx1RSUqJAIKBPf/rTuueeexLZR5xiNSNEAAAkVNwjRM8//7weffRRNTY26v3vf7+uvvpq3XnnncrOzpYk/dM//ZO8Xq+++MUvJrqvGBQdIWrplfrCpmZnGNZ2CACAFBd3ILrzzjt1zTXXqL6+ftSpsfnz56uqqiohncPozpotzXNIx/qlgz3SGo/VPQIAILXFPWX2uc99Tp///OdHhKFf/vKXsefXX3/91HuGMRmGoVWcaQYAQMLEHYi+9rWvjfr6N77xjSl3BhO3anBUiKX3AABM3YSnzPbs2SNJCofD2rt3r0zzvV2S33jjDbnd7sT3DmNiLyIAABJnwoFo06ZNkiI7VQ+9R8gwDOXn5+uOO+5IfO8wJk69BwAgcSYciJ566ilJ0h133MH0mA1EA5GvV+oZMJU1i5VmAABMVtz3EBGG7GGBy1C+UzIlvdJjdW8AAEhtEx4huvbaa/XII4+ovLxchjH6aERjY2PCOobTWz1H+s27kZVmF8y1ujcAAKSuCQei6D1CjBDZx9nRQBSwuicAAKS2CQeiCy+8UJJ08cUXD3s9GAwqIyNDDkfcezxiilZzphkAAAkR9z1E27Zt00svvSRJevrpp3XRRRfpoosu0tNPP53wzmF8nGkGAEBixB2IHnnkEZWUlEiS/vM//1N1dXX63ve+p7q6uglfw+fzaf369fJ6vdqwYYM6OjpGtOno6NCGDRvk9Xq1fv16+Xy+EW1uvPFGXXrppfF+hRkjuhfR4T7peL85fmMAADCmuANRMBhUZmam3n77bfn9fl155ZW6+OKLdeTIkQlfo7q6WpWVlWpsbFRpaemoYaqurk6lpaVqbGxUZWWlqqurh73/i1/8QvPnz4+3+zNKjtPQma7Ic6bNAACYvLgD0fLly/X9739f9957rz7ykY9IiozmZGVlTejznZ2d8vl8Ki8vlyRVVFSoqalpRLumpiZVVFRIksrLy+Xz+XT06FFJkt/vV319vT73uc/F2/0ZZxXTZgAATFncd0J/61vf0n/8x3/I4XBo8+bNkqS9e/dq3bp1E/p8e3u7ioqKYkv3PR6PnE6nurq6lJOTI0nq6uqSy+WSxxM5sMswDBUWFqqtrU15eXnaunWrbr31Vjmdzni7P6re3t6EXMcKy2c79aQc+suxfvVkh6zuzpRE65DK9ZgpqIV9UAv7oBb2YZrmmFsATVbcgWjx4sW66667hr3m9Xrl9Xon9PmhZ6ANNfSLjdfmscce0/z583XhhRfqzTffnGCvx9fa2pqQ61ghO5gnaZGef7tH+3tetbo7CZHK9ZhpqIV9UAv7oBb24HK5Enq9uANRMBhUQ0ODDhw4oO7u4fM03/72t0/7+aKiIrW3t8fSXSAQUCgUUnZ2dqxNbm6ugsGgAoGAPB6PTNOU3+9XYWGhfvGLX+jpp5/Wb3/7W/X396uzs1OXX3557GiRyVi8eHHKHk4bCBj6xsvS4Yy5WrlypdXdmZLe3l61tramdD1mCmphH9TCPqiFfbS0tCT8mnEHos2bN+u1117TZZddpry8vLh/YH5+voqLi9Xc3KyysjLV19errKxsRLvoexs3blRzc7OKi4uVl5enmpoa1dTUSJLefPNN/cM//MOUwpAkud3uCd8DZTcXuCKjae0hQyedbuU6U/9Ms1Sux0xDLeyDWtgHtbBeoqfLpEkEot/97nf6zW9+E7u/ZzJqamq0ZcsW1dbWasGCBaqtrZXf71dlZaUaGhokSVVVVdq0aZMeeughzZkzR9u3b5/0z5vJ5joMLco0dehk5OT7tdlW9wgAgNQTdyAqLi6OTWVNVklJiXbt2jXi9WgYkqSCggLt3Llz3OssXLhQzz777KT7MVOsniMdOhlZaUYgAgAgfnEHoo985CO66aab9MlPfnLElNnVV1+dsI5h4s6eI/3qKEvvAQCYrLgD0XPPPaecnBzt3r172OuGYRCILMKZZgAATE3cgeh001hIvqGbM07H3gwAAMx0ce9ULUXOIrvvvvv0jW98Q1JkT4aDBw8mtGOYuJVZkiHpaEjqSO29GQEAsETcgejxxx+PHcgavTH6xIkT+uY3v5nwzmFi3LMMLR3cEuOvAWv7AgBAKoo7EN1zzz36r//6L331q1/VrFmzJEkrVqzQK6+8kvDOYeKi02Yv91jbDwAAUlHcgejYsWNaunSppPc2RjJNUw5H3LcjIYFi9xExQgQAQNziDkQXXHCBfvKTnwx77Wc/+5k+8IEPJKxTiF9shIiVZgAAxC3uYZ2vfvWruuWWW/Szn/1MPT09uuaaa2QYhr7//e9PR/8wQauHBCJWmgEAEJ+4A1FBQYFqa2v1zjvv6Pnnn9ff/u3f6pxzzondTwRrLMuSHIZ0fEB6s096X6bVPQIAIHXEFYh+/vOf69///d/17rvvSoqMROzcuVNf+MIX9Pd///fT0T9MkCvD0DK3qX09kVEiAhEAABM34UD01FNP6bvf/a6++MUv6vLLL9f8+fPV0dGhp59+WnfffbcWLFigK664Yjr7itNY7ZH29UQ2aPxo3unbAwCAiAkHogceeEBbtmzRpz71qdhrCxcu1A033KDMzEw98MADBCKLnZ0VeeQIDwAA4jPhVWb79u3TlVdeOep7ZWVl2rdvX8I6hclZ7Yk8csgrAADxmXAgCgaDysnJGfW97OxshUKcGWG1VUMOeQ2bprWdAQAghUx4yiwcDmvv3r0yx/iLdqzXkTxLMqXZGVJPWGo9Kb3fbXWPAABIDRMORLm5uaqqqhrz/bFGj5A8jgxDK7JM/SUQmTYjEAEAMDFxrTKD/a2eI/0lEFl6f02+1b0BACA1xH10B+yNIzwAAIgfgWiGIRABABA/AtEMEz3TbH+31B/mRncAACaCQDTDLMqUsjKkoCm92mt1bwAASA0EohkmwzCYNgMAIE4EohkoGojYsRoAgIkhEM1AQ3esBgAAp0cgmoFWM0IEAEBcCEQzUHSEqKVX6mOlGQAAp0UgmoHOmi3Nc0j9pnSwx+reAABgfwSiGcgwDK3Kijxn2gwAgNMjEM1QqzyRR5beAwBwegSiGYq9iAAAmDgC0Qy1mkAEAMCEEYhmqGgg8vVKPQOsNAMAYDwEohlqgctQvlMyJb3CSjMAAMZFIJrB2KARAICJIRDNYGdHA1HA2n4AAGB3BKIZbDVnmgEAMCEOK36oz+fT5s2bFQgEVFBQoNraWi1YsGBYm46ODm3atEl+v18ej0fbt2/XkiVLFAqFdP3116uvr0/hcFjFxcX65je/qblz51rxVWyNU+8BAJgYS0aIqqurVVlZqcbGRpWWlqqurm5Em7q6OpWWlqqxsVGVlZWqrq6WJDkcDt1///1qaGjQo48+qqKiIv3gBz9I9ldICdFAdLhPOt7PSjMAAMaS9EDU2dkpn8+n8vJySVJFRYWamppGtGtqalJFRYUkqby8XD6fT0ePHpVhGPJ4Itswh8Nh9fSwhGosuU5DZ7oiz5k2AwBgbEmfMmtvb1dRUZEMw5AkeTweOZ1OdXV1KScnR5LU1dUll8sVCz6GYaiwsFBtbW3Ky8uTJN1www06ePCgli5dqu9973tT6lNvb++UPm9nKzJdOhKcpb1dQZ3jHLC6O+OK1mEm1yNVUAv7oBb2QS3swzTNWI5IlKQHItMcfepm6BebSJudO3eqv79f3/72t/XQQw/p5ptvnnSfWltbJ/1Zuys8eZakAv3urS5dfPQtq7szITO5HqmGWtgHtbAPamEPLpcroddLeiAqKipSe3t7LN0FAgGFQiFlZ2fH2uTm5ioYDCoQCMjj8cg0Tfn9fhUWFg67lsPh0Cc/+UndeuutUwpEixcvltvtnvTn7ezDHbP009el9sx8rVx5htXdGVdvb69aW1tndD1SBbWwD2phH9TCPlpaWhJ+zaQHovz8fBUXF6u5uVllZWWqr69XWVnZiHbR9zZu3Kjm5mYVFxcrLy9P77zzjgzDUE5OjkzT1BNPPKGSkpIp9cntdisrK2tK17CrC3JM6XXplZOzUuY7zuR6pBpqYR/Uwj6ohfUSPV0mWbTsvqamRlu2bIktt6+trZXf71dlZaUaGhokSVVVVdq0aZMeeughzZkzR9u3b5ckvf3227rtttvU398vSSopKdEdd9xhxddICdHNGduC0jshU7nOxP9DBABAqrMkEJWUlGjXrl0jXo+GIUkqKCjQzp07R7RZvny5Hn744Wnt30wy12FoUaapQycjJ9+vzba6RwAA2A87VacBzjQDAGB8BKI0EJ02e5lABADAqAhEaWA1gQgAgHERiNLA0DPNxtrjCQCAdEYgSgMrsyRD0tGQ1BGyujcAANgPgSgNuGcZWjK4h9hfA9b2BQAAOyIQpYnYfUSchQsAwAgEojQRu4+IESIAAEYgEKWJaCDax0ozAABGIBClidWsNAMAYEwEojSxLEtyGNLxAenNPqt7AwCAvRCI0oQrw9CywZVmbNAIAMBwBKI0soozzQAAGBWBKI1wYzUAAKMjEKWR1Z7IIyNEAAAMRyBKI0NHiMKsNAMAIIZAlEaWZEqzM6SesNR60ureAABgHwSiNOLIMLQiK/KcaTMAAN5DIEozsTPNCEQAAMQQiNLM2QQiAABGIBClGUaIAAAYiUCUZqKBaH+31B9mpRkAABKBKO0sypSyMqSgKb3aa3VvAACwBwJRmskwjNh+REybAQAQQSBKQ5xpBgDAcASiNMSZZgAADEcgSkOMEAEAMByBKA1FV5q19Ep9rDQDAIBAlI7Omi3Nc0j9pnSwx+reAABgPQJRGjIMQ6s40wwAgBgCUZpa5Yk8svQeAAACUdpiLyIAAN5DIEpTnGkGAMB7CERpKjpC5OuVegZYaQYASG8EojS1wCnlOyVT0iusNAMApDkCUZoyDCM2bcZKMwBAuiMQpbGzo4EoYG0/AACwmiWByOfzaf369fJ6vdqwYYM6OjpGtOno6NCGDRvk9Xq1fv16+Xw+SdLrr7+uG264QX/3d3+nq666SnV1dTJN7oGZjNWcaQYAgCSLAlF1dbUqKyvV2Nio0tJS1dXVjWhTV1en0tJSNTY2qrKyUtXV1ZIkp9Op22+/XY8//rh27dqlPXv26Iknnkj2V5gRONMMAIAIR7J/YGdnp3w+n8rLyyVJFRUVWrt2rbZt2zasXVNTk+68805JUnl5uWpqanT06FEtXLgw1sblcmnFihU6cuTIlPrU29s7pc+nquIMSXLrcJ/UfrxHZyT9n4bhonVI13rYCbWwD2phH9TCPkzTlGEYCb1m0v8KbG9vV1FRUeyLeDweOZ1OdXV1KScnR5LU1dUll8sljyeynbJhGCosLFRbW5vy8vJi13rnnXf05JNP6oc//OGU+tTa2jqlz6eyfGO1Ok2Xnth/SGsc9lhuls71sBtqYR/Uwj6ohT24XK6EXi/pgWis+32GJr2JtOnr69O//uu/6sYbb9SyZcum1KfFixfL7XZP6Rqp6pz9s/TUcam34P1auWDA0r709vaqtbU1rethF9TCPqiFfVAL+2hpaUn4NZMeiIqKitTe3h4b7goEAgqFQsrOzo61yc3NVTAYVCAQkMfjkWma8vv9KiwslCT19/fri1/8oi688EJt3Lhxyn1yu93Kysqa8nVS0TlnmHrquHQw5FJWVmKHHycrnethN9TCPqiFfVAL6yV6ukyy4Kbq/Px8FRcXq7m5WZJUX1+vsrKyEe3KyspUX18vSWpublZxcbHy8vIUDod16623qqCgQF/60peS2veZiDPNAACwaJVZTU2NduzYIa/Xq927d6uqqkp+v1/r1q2LtamqqtLu3bvl9Xq1Y8cObd26VZL07LPP6vHHH9eePXu0bt06rVu3Tj/+8Y+t+BozAmeaAQBgwZSZJJWUlGjXrl0jXm9oaIg9Lygo0M6dO0e0KS0t1YEDB6a1f+kkujljW1B6J2Qq12mPaTMAAJKJnarT3FyHoUWZkeeMEgEA0hWBCFo1eG8gGzQCANIVgQhaFdnuiREiAEDaIhCBG6sBAGmPQIRhZ5pxUC4AIB0RiKCVWZIh6WhI6ghZ3RsAAJKPQAS5ZxlaMrgL/V8D1vYFAAArEIggach9RPY43xUAgKQiEEHSexs0MkIEAEhHBCJIem+EaB8rzQAAaYhABEnvBSJWmgEA0hGBCJKkZVmSw5COD0hv9lndGwAAkotABEmSK8PQssGVZmzQCABINwQixAzdoBEAgHRCIELMKm6sBgCkKQIRYhghAgCkKwIRYlYPnnq/r1sKs9IMAJBGCESIWZIpzc6QesLS6yet7g0AAMlDIEKMI8PQBYOjRDvbre0LAADJRCDCMF96X+Txnjeld0NMmwEA0gOBCMNcNz+ya/WxfunuN63uDQAAyUEgwjAZhqGvLo48v+cNqYtRIgBAGiAQYYTr5ktr5kSO8bj7Dat7AwDA9CMQYYSho0T/8ab0DqNEAIAZjkCEUX1ivnTO4CjRvzNKBACY4QhEGFWGYeirxZHn9zBKBACY4QhEGNO1+ZFRohPcSwQAmOEIRBhThmGoenCUiHuJAAAzGYEI41qXL53riYwS3cUoEQBghiIQYVwZhqHqxZHn//mmdJRRIgDADEQgwmmty5fOY5QIADCDEYhwWsaQfYkYJQIAzEQEIkxIdJQoMCDVHba6NwAAJBaBCBNiDLmX6P97S+oMMkoEAJg5CESYsGvypfMHR4m4lwgAMJMQiDBhxpB9iRglAgDMJJYEIp/Pp/Xr18vr9WrDhg3q6OgY0aajo0MbNmyQ1+vV+vXr5fP5Yu/dfPPN+tCHPqRLL700md2GpKvzpAui9xIxSgQAmCEsCUTV1dWqrKxUY2OjSktLVVdXN6JNXV2dSktL1djYqMrKSlVXV8fe27hxo+6///5kdhmDTh0leptRIgDADJD0QNTZ2Smfz6fy8nJJUkVFhZqamka0a2pqUkVFhSSpvLxcPp9PR48elSR9+MMf1hlnnJG8TmOYq/KkD8yVuhklAgDMEI5k/8D29nYVFRXJMAxJksfjkdPpVFdXl3JyciRJXV1dcrlc8ng8kiKjEoWFhWpra1NeXl7C+9Tb25vwa850txVl6FMnZuveN03dkt+r+c6pXzNaB+phPWphH9TCPqiFfZimGcsRiZL0QGSao0+xDP1iE2mTSK2trdNy3ZlskSmtzFiu/eE5qv7rMf1r5pGEXZt62Ae1sA9qYR/Uwh5cLldCr5f0QFRUVKT29vZYugsEAgqFQsrOzo61yc3NVTAYVCAQkMfjkWma8vv9KiwsnJY+LV68WG63e1quPZN9rStDnzoo1fcXaOvSeVMeJert7VVrayv1sAFqYR/Uwj6ohX20tLQk/JpJD0T5+fkqLi5Wc3OzysrKVF9fr7KyshHtou9t3LhRzc3NKi4unpbpMklyu93KysqalmvPZNe5TV3YJr1wwtC9b7u1fWliRvCoh31QC/ugFvZBLaw3HTNGlqwyq6mp0Y4dO+T1erV7925VVVXJ7/dr3bp1sTZVVVXavXu3vF6vduzYoa1bt8beu+GGG/SZz3xGnZ2duvTSS7V9+3YrvkbaG7p79f//ltTBijMAQIpK+giRJJWUlGjXrl0jXm9oaIg9Lygo0M6dO0f9/FivI/n+Lk+6aK70/Amp9rC0fanVPQIAIH7sVI0pGbovEaNEAIBURSDClH0sV7p4rtQTlr572OreAAAQPwIRpuzUUSI/o0QAgBRDIEJCfDRX+uAZUi+jRACAFEQgQkIMXXG2g1EiAECKIRAhYbxDRom2M0oEAEghBCIkzNBRovvektr7GCUCAKQGAhESypsrfYhRIgBAiiEQIaGGjRIdYZQIAJAaCERIuPJc6W/PkE4ySgQASBEEIiTc0H2J7jsitTFKBACwOQIRpkVZDqNEAIDUQSDCtDAMQzWDo0TfY5QIAGBzBCJMmytzpEsGR4m2MUoEALAxAhGmzdBRou8zSgQAsDECEabVFTnSh+dFRom+wygRAMCmCESYVkP3Jfr+EekIo0QAABsiEGHaXZEj/Z95Ul9Y+s4hq3sDAMBIBCJMu6GjRD9ok95ilAgAYDMEIiTF5TnS2sFRom2MEgEAbIZAhKQYuns1o0QAALshECFpLst+b5SIe4kAAHZCIELSDN2X6AdHpN3vmDJNRooAANYjECGpSrMjv4KmVPYX6aIXpJ/6TYXCBCMAgHUIREgqwzD081XSLWdJ7gxpT0D67D5p6f9K97Q5FDD5RxIAkHz87YOkm+8ydO8yQ4cvkb5WLBW4pDf6pNsPO3XViTX68iGHDp9kxAgAkDwEIlgmz2nojsWGXv+Q9MMV0gp3WN2apf9sd2rJ/0rXv2zqTycIRgCA6UcgguUyZxm6scjQ82v69O/uV1V6xoAGTOmhjsg9RpftNfVop6kwN2ADAKYJgQi2YRjSh53H9djKoPZcKH22QHIY0jPvSuteklb9Ufr+EVO9AwQjAEBiEYhgS+fNNfSTsw299iHp1r+R5jmkAz3S5w5Ii/8gbX3d1NtBghEAIDEIRLC1hZmGti0xdPhvpbuWSosypbdD0tZWadEfpH86YOpAD8EIADA1BCKkhLkOQ//2PkMtH5R+tkq6aK50MhzZ4HHlc9I1L5p6pouNHgEAk0MgQkpxZBiqWGDofz8gPXO+tC5fMiQ9dlS67M/SxX+SHmKjRwBAnAhESEmGYWhttqGH1xja/0Hpn86UMjOkP52Qrt8nlfyv9N3Dpp58x9RfAqaO9JkKEpIAAGNwWN0BYKqWZRnasVz6erGpHUeke9+UDvdJW3wj285zmJrvVOSXS8qPPh/8/bBHp+SeZST/CwEAko5AhBkj32XozsXSre8z9YBf+u8OqS0ovR2UOkNSWNKx/sivV3snds05s4YEqFND1GBwOsMheWZFfs2JPmZEpvcAAKmBQIQZJ3OWoZvOlG46873Xwqaprv5IOHo7NPhryPPOUV4PmVL3QORX68n4+zE7w3wvKGWMEpqGPPec5nlWhpQ1K3L+W2ZGZMoQAJA4lgQin8+nzZs3KxAIqKCgQLW1tVqwYMGwNh0dHdq0aZP8fr88Ho+2b9+uJUuWSJJeeOEF1dTUKBgMatmyZdq2bZvmzJljxVdBisgwDOU5pTyntGIC7U3T1PGBiQWowMDwX9F9I/vCkV9HQ4n9LoakzAwzFpCyMiT3YGhyDwlOWbMi4enU14Y9Dvns7IzIRphOQ+rvM9QedionKM11mHIakjMj8p7TIJABmHksCUTV1dWqrKyU1+vV/fffr7q6Om3btm1Ym7q6OpWWlurGG29UY2Ojqqur9cADDygcDuu2227TXXfdpXPOOUdf//rX9aMf/Uhf+MIXrPgqmKEMw9A8R2RDyKVxfM40TQXNSDDqHhKSxnoe/X33adr1hKX+waBlSuoNR35Nn0xJa6S9o7+bIXNYQIoGqcm+5hjy+1i707w2VhuHEdn1PBrZhj5Gc9yw16LPJ/he9DVTUtgcfJRkmoOPpzyPtRl8nOjnTDPyc4N9GWoLZevgOxlyd5syJGUYkRUxRvRx8LVhj2O8Zpzy2VHfm8z1TtOv0Wpw2tcJ3kgiw0zyxi2dnZ26+uqr9fvf/16GYSgQCGjt2rXau3f4f3nPP/98/fa3v5XH45Fpmrrkkkv02GOP6a233lJNTY127dolSTp48KD+7d/+TY8//njcfXnppZcUDAa1cuVKZWVlJeT7YfJ6enq0f/9+6jGGUNiMBaGegTEew1LvwCmPQ97vHad932DoCpmRnxUMmxqQobD4SwnWOzWgjhVcJxS0Jvm6aZoa6O+X0+GQYRinbT9eH8fr+9BwOTSEjhU8J/TeKAF4rPfGus5owXi896KGpoyhgWPM5xNo/7FjLynXaWjNmjVKlKSPELW3t6uoqCiW/D0ej5xOp7q6upSTkyNJ6urqksvlksfjkRT5fwmFhYVqa2tTW1ubzjrrrNj1zjzzTLW1tU2qL6FQZC6jpaWF/ydiA9FsTj0mzjX4a168H8zQuJtumKap/v5+OQb/wx8d2ZD53n+UYq+d8t6w14a2G+t985R2sUcjNlIy+vsa8f7Qx4mYUNtTrj+UEfufU14bq+0EXht2XVMyFdlwNPLvxHufGK0/E3rNnMJnx3gtrcy26OeOlQzSVKYRUiiU2L8nkh6IxhqQGvoX4HhtRntvsn95Rj+XkcF2THZgGIZcLpfV3YBG1sIY8QTJMzwIAZBCISPh/8c56YGoqKhI7e3tsf/HEwgEFAqFlJ2dHWuTm5urYDCoQCAQmzLz+/0qLCzUwMCAjhw5Emt75MgRFRYWTqov559//lS/DgAAmAGSPjSSn5+v4uJiNTc3S5Lq6+tVVlY2ol1ZWZnq6+slSc3NzSouLlZeXp5Wr16td999V3/9618lSf/93/8tr9ebvC8AAABmnKTfVC1F7hHZsmWLuru7tWDBAtXW1kqSKisr1dDQIEny+/3atGmTOjo6NGfOHG3fvl1Ll0bW+zz//POqqalRKBRSSUmJtm3bFrvfCAAAIF6WBCIAAAA74W5iAACQ9ghEAAAg7RGIAABA2iMQAQCAtEcgAgAAaY9ABAAA0h6BCAAApD0CEQAASHtpHYh8Pp/Wr18vr9erDRs2qKOjw+oupY2uri7ddNNN+uhHP6qrr75at99+u4LBoCTpySeflNfrVVlZme68804NDAxY3Nv0cfvtt2v58uXq7++XRC2scPLkSd1xxx3yer362Mc+pnvuuUcStbDCM888o2uvvVbr1q3TddddpxdeeEEStUiGr3zlK1q7du2w/x5J4//Z33PPPbryyitVVlamn/70p/H/UDONXX/99eYTTzxhmqZp/uhHPzI3b95scY/SR1dXl/nHP/7RNE3THBgYML/0pS+ZP/jBD8wTJ06YH/7wh8033njDDIfD5uc+9zmzvr7e4t6mh9///vfmli1bzGXLlpmhUIhaWKSmpsa8++67Y7/v6OigFha55JJLzJaWFtM0TfOpp54y161bRy2S5LnnnjPffvvt2H+PTNMc98/+D3/4g/mJT3zC7OvrM999913zsssuMw8dOhTXz0zbEaLOzk75fD6Vl5dLkioqKtTU1GRxr9JHdna2LrroIklSRkaGVq9erSNHjujZZ5/VBRdcoIULF8owDFVUVOiJJ56wuLczX09Pj+666y5t2bIl9hq1SL7u7m79+te/1uc///nYa/Pnz6cWFjpx4kTssaCggFokycUXX6z8/Pxhr433Z//EE0/ouuuuk8vl0rx58+T1etXY2BjXz3QkrPcppr29XUVFRTIMQ5Lk8XjkdDrV1dWlnJwci3uXXvr6+vTwww/r1ltv1auvvqozzzwz9l5RUZHa29st7F16uOuuu7Rhw4Zh/+y3t7dTiyR74403lJubq+9+97v605/+pHnz5mnz5s3UwiJ33323brnlFmVmZiocDuvBBx/Uk08+SS0sMt6/B+3t7br00kuHvXfo0KG4rp+2I0TmGGfaRgMSkiMcDmvLli360Ic+pEsvvXTMumD67NmzR4cPH9bVV1897HVqkXz9/f3y+Xy6+OKLtWvXLm3YsEH//M//TC0sMDAwoPvuu08//OEP9Zvf/EY1NTX6l3/5F4XDYau7lrbG+/dgtPfi/fs8bQNRNFlG/xADgYBCoZCys7Ot7Via2bp1qxwOh77yla9IitTlyJEjsffb2tpUWFhoVffSwgsvvKB9+/bp8ssv1+WXXy5JKi8vV15eHrVIsqKiIrndbpWVlUmSLrvsMgUCAf69sMC+ffv07rvvavXq1ZKkyy+/XEeOHNGZZ55JLSwy3r8HRUVFamtrG/ZeQUFBXNdP20CUn5+v4uJiNTc3S5Lq6+tj/xFCcmzfvl1+v1/f+c53Ykn+0ksv1Z49e/TWW2/JNE394he/kNfrtbinM1tlZaV+97vf6amnntJTTz0lSWpqatKVV15JLZIsLy9Pa9as0Z/+9CdJ0osvvqjMzEytXbuWWiRZYWGh3njjDb355puSIiOpLpeLWlhovL8fvF6vHn74YQWDQR0/flyNjY1x18Uw03gstqWlRVu2bFF3d7cWLFig2trauBMlJqelpUVXXXWV3v/+98vlckmSLrnkEm3ZskVPPPGE7r77bg0MDOiDH/xgbBQJybF8+XK9/PLLcjgc1MICr732mm6//XYFAgFlZmbq9ttv13nnnUctLPDII4/ohz/8oTIyMuRwOHTbbbfp4osvphZJcOutt+q5556T3+9XQUGBLrzwQt11113j/tnffffd+tWvfiVJ+sd//Eddf/31cf3MtA5EAAAAUhpPmQEAAEQRiAAAQNojEAEAgLRHIAIAAGmPQAQAANIegQgAAKQ9AhEAAEh7BCIAAJD2CEQAACDtEYgAAEDaIxABAIC09/8AE7ImpCAGFeEAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "_, losses = predict(model, train_dataset)\n",
    "plt.xlim(0, 100)\n",
    "sns.kdeplot(losses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: ylabel='Density'>"
      ]
     },
     "execution_count": 227,
     "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, 100)\n",
    "sns.kdeplot(losses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: ylabel='Density'>"
      ]
     },
     "execution_count": 228,
     "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": 135,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions, losses = predict(model, train_dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_array = np.array(losses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [],
   "source": [
    "stdev = np.std(loss_array)\n",
    "mean = np.mean(loss_array)\n",
    "THRESHOLD = mean + stdev * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check on test_normal_dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of intervals exceeding std dev loss: 127/2495\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 std dev loss: {exceed_count}/{len(test_normal_dataset)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check on test_anomaly_dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of intervals exceeding std dev loss: 772/5995\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 std dev loss: {exceed_count}/{len(test_anomaly_dataset)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## plot construction error vs original"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_prediction(data, model, title, ax):\n",
    "    predictions, pred_losses = predict(model, [data])\n",
    "\n",
    "    ax.plot(data[:,2], label='true')\n",
    "    ax.plot(predictions[0].reshape(60,5)[:,2], label='reconstructed')\n",
    "    ax.set_title(f'{title} (loss: {np.around(pred_losses[0], 2)})')\n",
    "    ax.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "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": 206,
   "metadata": {},
   "outputs": [],
   "source": [
    "\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",
    "            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": 207,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we want to identify the count of anomalies in each interval in the \"test_anomaly_dataset\"\n",
    "fault_segments = [ fault_data[i:i + seq_len] for i in range(0, len(anomaly_data) - seq_len + 1 ,10) ]\n",
    "# len(test_anomaly_dataset)\n",
    "# count all occurances of 1 in fault_segments[i]\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": 208,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5995"
      ]
     },
     "execution_count": 208,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(fault_segments)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "428"
      ]
     },
     "execution_count": 209,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(np.array(anomaly_flag_actual) > 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "594"
      ]
     },
     "execution_count": 210,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# there are 50 - 100 minute segments where there is an anomaly\n",
    "sum(np.array(anomaly_count_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [],
   "source": [
    "_, losses = predict(model, test_anomaly_dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {},
   "outputs": [],
   "source": [
    "anomaly_flag_prediction = [ l > THRESHOLD for l in losses ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "772"
      ]
     },
     "execution_count": 213,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(np.array(anomaly_flag_prediction))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {},
   "outputs": [],
   "source": [
    "result_mat = confusion_matrix(anomaly_flag_actual, anomaly_flag_prediction)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[4872  695]\n",
      " [ 351   77]]\n"
     ]
    }
   ],
   "source": [
    "print(result_mat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# actual\n",
    "# negative: 714 vs positive: 286\n",
    "\n",
    "# predict all as positive\n",
    "# 0  0 \n",
    "# 714 286\n",
    "\n",
    "# predict all as negative\n",
    "# 714 286\n",
    "# 0    0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "77 351 695 4872\n",
      "5223\n",
      "772\n"
     ]
    }
   ],
   "source": [
    "tn, fp, fn, tp = result_mat.ravel()\n",
    "print(tp, fn, fp, tn)\n",
    "print(tn + fn )\n",
    "print(fp + tp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.875157176216993\n",
      "0.17990654205607476\n",
      "0.8255212677231026\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": 218,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "only 11.07913669064748 of flagged intervals are actual\n"
     ]
    }
   ],
   "source": [
    "print(f\"only {tp / fp * 100} of flagged intervals are actual\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## plot regions of predicted anomalies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### juxtapose over anomalous region"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {},
   "outputs": [],
   "source": [
    "_, losses = predict(model, test_anomaly_dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [],
   "source": [
    "anomaly_flag_prediction = [ l > THRESHOLD for l in losses ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_segments = []\n",
    "count = 0\n",
    "for i in anomaly_flag_prediction:\n",
    "    x_segments.append([count*10, count*10 + 60])\n",
    "    count = count + 1\n",
    "y_segments = [ [0,0] for i in x_segments]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "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": 233,
   "metadata": {},
   "outputs": [],
   "source": [
    "_, losses = predict(model, whole_dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "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",
    "    x_segments.append([count*10, count*10 + 60])\n",
    "    count = count + 1\n",
    "y_segments = [ [0,0] for i in x_segments]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}