battery-anomaly-detection/notebooks/multivar_anomaly_detection.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multivariate Time Series Anomaly Detection"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## boilerplate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "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": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x7fe8283d0c30>"
      ]
     },
     "execution_count": 30,
     "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": 31,
   "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": 32,
   "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": 33,
   "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": 34,
   "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": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'fault incidents')"
      ]
     },
     "execution_count": 35,
     "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": 36,
   "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": 37,
   "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": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(100774, 5)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_data.to_numpy().shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(25000, 5)"
      ]
     },
     "execution_count": 39,
     "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": 40,
   "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, 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": 41,
   "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": 42,
   "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": 43,
   "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": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 1, 64])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hidden.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 60, 64])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = hidden\n",
    "x = x.repeat((1,60,1))\n",
    "x.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "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": 47,
   "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": 48,
   "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": 49,
   "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": 50,
   "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": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1: train loss 38.86843705290907 val loss 31.42728550720215\n",
      "Epoch 2: train loss 33.15285356688031 val loss 30.997470954895018\n",
      "Epoch 3: train loss 30.248853377602938 val loss 26.995422161102294\n",
      "Epoch 4: train loss 20.282794476549423 val loss 23.825604535102844\n",
      "Epoch 5: train loss 16.377526552212814 val loss 24.040671655654908\n",
      "Epoch 6: train loss 15.591873613832393 val loss 23.611765365600586\n",
      "Epoch 7: train loss 15.221078222887085 val loss 23.626889554977417\n",
      "Epoch 8: train loss 14.928746445538247 val loss 23.297098026275634\n",
      "Epoch 9: train loss 14.680893610814556 val loss 22.969089159965517\n",
      "Epoch 10: train loss 14.512633638058198 val loss 23.19877135181427\n",
      "Epoch 11: train loss 14.2985059658355 val loss 23.137717478752137\n",
      "Epoch 12: train loss 14.14401307029338 val loss 22.674271161079407\n",
      "Epoch 13: train loss 13.994837189089903 val loss 23.112126132965088\n",
      "Epoch 14: train loss 13.851284402903522 val loss 23.070360283851624\n",
      "Epoch 15: train loss 13.70330542975625 val loss 22.495113295555115\n",
      "Epoch 16: train loss 13.540243803283301 val loss 22.37432998752594\n",
      "Epoch 17: train loss 13.400565888854704 val loss 21.95571859359741\n",
      "Epoch 18: train loss 13.243236444761811 val loss 21.879435116767883\n",
      "Epoch 19: train loss 13.11524921701805 val loss 21.32238283443451\n",
      "Epoch 20: train loss 13.023473753114056 val loss 21.33163222026825\n",
      "Epoch 21: train loss 12.914216863249937 val loss 20.949963761806487\n",
      "Epoch 22: train loss 12.810761129451409 val loss 20.877476187705994\n",
      "Epoch 23: train loss 12.69247521517744 val loss 20.65351935005188\n",
      "Epoch 24: train loss 12.58193458560821 val loss 20.758116281032564\n",
      "Epoch 25: train loss 12.343759736253649 val loss 20.297971497535706\n",
      "Epoch 26: train loss 12.229980894467033 val loss 20.63231620645523\n",
      "Epoch 27: train loss 12.055519421871677 val loss 20.78471545791626\n",
      "Epoch 28: train loss 11.89597285738156 val loss 19.9953883562088\n",
      "Epoch 29: train loss 11.808162051556435 val loss 20.159356714725494\n",
      "Epoch 30: train loss 11.71486991803656 val loss 20.361471618175507\n",
      "Epoch 31: train loss 11.573541547941124 val loss 20.27868254184723\n",
      "Epoch 32: train loss 11.512939579647307 val loss 19.748725774765013\n",
      "Epoch 33: train loss 11.440065460165318 val loss 19.699584414958952\n",
      "Epoch 34: train loss 11.357310095807497 val loss 19.62766425085068\n",
      "Epoch 35: train loss 11.249971907290766 val loss 19.75169884300232\n",
      "Epoch 36: train loss 11.168876630554177 val loss 19.306912044525145\n",
      "Epoch 37: train loss 11.077471166227884 val loss 19.248602478027344\n",
      "Epoch 38: train loss 11.043370378876528 val loss 19.437982461452485\n",
      "Epoch 39: train loss 10.979938003298354 val loss 19.31774957513809\n",
      "Epoch 40: train loss 10.902421442932711 val loss 18.986604588508605\n",
      "Epoch 41: train loss 10.825572672097579 val loss 19.14624274110794\n",
      "Epoch 42: train loss 10.748964093638858 val loss 19.890348776817323\n",
      "Epoch 43: train loss 10.690735791005004 val loss 19.505379387378692\n",
      "Epoch 44: train loss 10.635939868345652 val loss 19.15189327764511\n",
      "Epoch 45: train loss 10.575765307883978 val loss 19.27545291376114\n",
      "Epoch 46: train loss 10.517353279062366 val loss 19.12798267364502\n",
      "Epoch 47: train loss 10.47650368398964 val loss 19.262065041542055\n",
      "Epoch 48: train loss 10.401294536857536 val loss 19.28793490743637\n",
      "Epoch 49: train loss 10.354887735176257 val loss 19.479482122421263\n",
      "Epoch 50: train loss 10.335227646523817 val loss 19.279777328014372\n",
      "Epoch 51: train loss 10.315433880344184 val loss 19.148805601596834\n",
      "Epoch 52: train loss 10.240681151253188 val loss 18.902668324947356\n",
      "Epoch 53: train loss 10.180605205664541 val loss 19.09464505434036\n",
      "Epoch 54: train loss 10.128474695935287 val loss 18.842494136333464\n",
      "Epoch 55: train loss 10.08075198671376 val loss 19.11138597726822\n",
      "Epoch 56: train loss 10.096781223426623 val loss 18.495564115524292\n",
      "Epoch 57: train loss 10.036804260136899 val loss 18.887975926399232\n",
      "Epoch 58: train loss 10.004227935948352 val loss 18.73034571170807\n",
      "Epoch 59: train loss 9.976196754007129 val loss 18.601321640491484\n",
      "Epoch 60: train loss 9.906925555635876 val loss 18.60232736825943\n",
      "Epoch 61: train loss 9.865915280463371 val loss 18.44057076215744\n",
      "Epoch 62: train loss 9.854688118226901 val loss 18.460704574584963\n",
      "Epoch 63: train loss 9.881754001277482 val loss 18.654272445201872\n",
      "Epoch 64: train loss 9.819119888199731 val loss 18.61281745147705\n",
      "Epoch 65: train loss 9.791684808760898 val loss 18.031773747444152\n",
      "Epoch 66: train loss 9.74261095851855 val loss 18.42790675544739\n",
      "Epoch 67: train loss 9.691091270834438 val loss 18.06329113674164\n",
      "Epoch 68: train loss 9.692825360515418 val loss 18.32570272397995\n",
      "Epoch 69: train loss 9.695701065661298 val loss 17.89037527036667\n",
      "Epoch 70: train loss 9.687506776930961 val loss 17.886078037738802\n",
      "Epoch 71: train loss 9.564859582101255 val loss 17.74414353466034\n",
      "Epoch 72: train loss 9.540258792626709 val loss 16.97416575050354\n",
      "Epoch 73: train loss 9.526702670237363 val loss 16.969112629413605\n",
      "Epoch 74: train loss 9.524115598081051 val loss 16.92461084794998\n",
      "Epoch 75: train loss 9.438481383269709 val loss 17.156900886058807\n",
      "Epoch 76: train loss 9.431714758552065 val loss 16.5725666513443\n",
      "Epoch 77: train loss 9.314281430146465 val loss 16.252663085460664\n",
      "Epoch 78: train loss 9.346432527095665 val loss 16.173862711429596\n",
      "Epoch 79: train loss 9.199182813830713 val loss 15.894011188983917\n",
      "Epoch 80: train loss 9.25145694366731 val loss 15.820341364383697\n",
      "Epoch 81: train loss 9.116767721171888 val loss 15.960952501773834\n",
      "Epoch 82: train loss 9.072696581527262 val loss 15.735157964229584\n",
      "Epoch 83: train loss 9.114809783993199 val loss 15.55242994260788\n",
      "Epoch 84: train loss 9.054173212451833 val loss 15.36225093603134\n",
      "Epoch 85: train loss 9.119249103962488 val loss 15.256216056346894\n",
      "Epoch 86: train loss 8.962191241812748 val loss 15.580801096916199\n",
      "Epoch 87: train loss 8.980852625673906 val loss 15.217423192977906\n",
      "Epoch 88: train loss 8.91950746595043 val loss 15.25197039270401\n",
      "Epoch 89: train loss 8.826644572315647 val loss 15.15044539308548\n",
      "Epoch 90: train loss 8.858168052341911 val loss 15.222327210903167\n",
      "Epoch 91: train loss 8.76176962023906 val loss 14.995795167922974\n",
      "Epoch 92: train loss 8.720511651876926 val loss 15.157920863628387\n",
      "Epoch 93: train loss 8.682562481192623 val loss 14.835923408985138\n",
      "Epoch 94: train loss 8.701011724561505 val loss 14.898563205718995\n",
      "Epoch 95: train loss 8.657228771705865 val loss 14.796268848896027\n",
      "Epoch 96: train loss 8.535928185955976 val loss 14.77586179304123\n",
      "Epoch 97: train loss 8.601159562732294 val loss 14.683023731231689\n",
      "Epoch 98: train loss 8.605023592373245 val loss 14.646459495544434\n",
      "Epoch 99: train loss 8.547713996861363 val loss 14.5896998462677\n",
      "Epoch 100: train loss 8.467137120535432 val loss 14.808863736629487\n"
     ]
    }
   ],
   "source": [
    "model, history = train_model(\n",
    "  model, \n",
    "  train_dataset, \n",
    "  val_dataset, \n",
    "  n_epochs=100\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "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": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "date = datetime.date.today().strftime('%y-%m-%d')\n",
    "MODEL_PATH = f'model_save/multivar_model_{date}_01.pth'\n",
    "\n",
    "torch.save(model, MODEL_PATH)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "# reload the model\n",
    "model = torch.load('model_save/model_.pth')\n",
    "model = model.to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Check reconstruction error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "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": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "_, losses = predict(model, test_normal_dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: ylabel='Density'>"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "_, losses = predict(model, train_dataset)\n",
    "plt.xlim(0, 100)\n",
    "sns.kdeplot(losses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: ylabel='Density'>"
      ]
     },
     "execution_count": 57,
     "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": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: ylabel='Density'>"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlUAAAGcCAYAAADwCVVTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABFIklEQVR4nO3de3xU1b3//9eeXCDJGHKDXEAlCEUsoKWiVQtGZWasQoPGgtpfc+qlsbQcxIKGU40JrUWgidb69UtbpD3f1qMtTTWxVkmIaK1aFYRToEaLsVEkk4RAAkwSmFz2749JplAu5jKTueT9fDwwO7MvszYfgm/WWrO2YZqmiYiIiIgMiiXQDRAREREJBwpVIiIiIj6gUCUiIiLiAwpVIiIiIj6gUCUiIiLiAwpVIiIiIj6gUCUiIiLiA5GBbkAo2rFjB6ZpEhUVFeimiIiISB91dHRgGAZf+MIX/HJ99VQNgGma3l8SWKZp4na7VYsgoFoED9UiuKgewcPf/+9WT9UAREVF4Xa7mThxIrGxsYFuzrDW1tZGdXW1ahEEVIvgoVoEF9UjeOzcuRPDMPx2ffVUiYiIiPiAQpWIiIiIDyhUiYiIiPiAQpWIiIiIDyhUiYiIiPiAQpWIiIiIDyhUiYiIiPiAQpWIiIiIDyhUiYiIiPiAQpWIiIiIDyhUiYiIiPiAQpWIiIiIDyhUiYiIiPhAQEJVTU0NOTk5OBwOcnNzaWxsPOmYxsZGcnNzcTgc5OTkUFNT4923bds25s6di91uZ/HixbS2tgKwe/du5s+fT3Z2Ntdffz0/+clPvOc8/vjjXHHFFWRnZ5Odnc26dev8fp8iIiIyfAQkVBUWFpKXl0dFRQVZWVmUlJScdExJSQlZWVlUVFSQl5dHYWEhAN3d3axYsYJVq1ZRWVlJamoqGzZsAGDixIn8/ve/p7y8nLKyMt544w1ef/117zVvuukmysvLKS8vZ9GiRUNzs//mWLfJ/x4xOdplBuT9RURExD8ih/oNm5qaqKmpwW63A7BgwQJmzZrFmjVrTjiusrKSgoICAOx2O0VFRRw4cIB9+/YRHx/P9OnTAVi4cCFLly5lyZIljBw50nv+sWPHcLvdfr2X9vb2zzxm3zF422XhHVcE77gs/G+rgds0mBrbzXOTj5Ee7dcmhr3eGvSlFuJfqkXwUC2Ci+oRPEzTxDAMv11/yENVfX096enp3puyWq1ERUXR3NxMYmIiAM3NzURHR2O1WgEwDIO0tDScTidOp5OxY8d6r5eRkYHT6fR+/8knn7B48WJqa2u55ZZb+PKXv+zdV1ZWxpYtWxg3bhz33nsvEyZMGNS91NbWnvB9h2nwflcMu7qs7OqKY2dXHI3myanJwGR3m4XZ/2vhp7EfMj7i2KDaISfXQgJHtQgeqkVwUT2CQ3S0/3ozhjxUmeaph72OT45nOuZU+44/95xzzuH555+npaWFu+++m61btzJz5kxuvvlmFi1aRGRkJGVlZdx1111s3rx5UPcyfvx4YmJiAPj0mIGjOpqPj504ohqBydRYk0us3Vx6VjeXWLsxgBs+iObDoyO469gF/GHyMWZaNRw4EO3t7dTW1p5QCwkM1SJ4qBbBRfUIHnv27PHr9Yc8VKWnp1NfX+/tgnO5XHR0dJCQkOA9JikpCbfbjcvlwmq1YpomDQ0NpKWl0dXVRV1dnffYuro60tLSTnqfhIQErrrqKl566SVmzpzJ6NGjvfvmz5/Pww8/TFNTEykpKQO+l5iYGGJjY+noNrm9Gj4+BomR8OVR8KVRcFk8zIw3iIuwABEnnPvGF03m7oStRwyurx7JxqlwXbL/uiTDXW8tJPBUi+ChWgQX1SPw/Dn0BwGYqJ6SkkJmZiZVVVUAlJaWYrPZTjrOZrNRWloKQFVVFZmZmSQnJzN16lRaWlrYvXs3ABs3bsThcACwd+9e7zyqo0eP8uqrrzJp0iQAGhoavNd+8803iYqKIikpySf3dP9H8OZhGBUJWy+G8ukG/3WuQVaiQVzEqQs4Otrg5YvAkQRt3ZC9C/7bqd4qERGRUDXkPVUARUVF5OfnU1xczJgxYyguLqahoYG8vDzKy8sBWLZsGcuXL+eZZ54hLi6OtWvXAmCxWFi9ejX5+fl0dHQwadIkli5dCsC7777L+vXriYiIoLu7m6uvvpqFCxcCnk8TVldXYxgGsbGxPPHEE1gsg8+ULzSZFO/1bG84HybE9D0FWyMNnp9mcuf78JsGuP19qHeb5J/j/zQtIiIivmWYp5vAJKe1a9cu3G431gkXcMXukRzshP8cB49NGlgQ6jZNVtTgDWf/OQ4enQgWBavP1NbWRnV1NVOmTFG3eoCpFsFDtQguqkfw2LlzJ4ZhMG3aNL9cXyuqD5Bpwn98GM3BTph5Fvz4vIFfy2IYrJ1oUDLR8/3jn8Kt73nWtBIREZHQoFA1QIdNz7pTCZHw289DtGXwvUr3nG3wPxdAlAEbG+H6v8GRTgUrERGRUKBQNUCunk/z/fJ8yOzHPKrPckuqwQvTwRoBW1rgvprPPEVERESCgELVIHw3rZP5o30/78mWZPDcVM/2Bif8s129VSIiIsFOoWqAojD54dkdfrv+NUkG9kToNOGHtX57GxEREfERhaoBSjI6iPbz794Pep6i8+t6+KBNvVUiIiLBTKFqgCKHYLWDS+INvpoC3cDKf/r//URERGTgFKqC3A8yPV9/2wg7XeqtEhERCVYKVUFuutVg4RjPdqF6q0RERIKWQlUIKBzvKVR5E2w9rN4qERGRYKRQFQLOjzP4Rppn+0H1VomIiAQlhaoQUTDeMzm+4iD8pUW9VSIiIsFGoSpETIgxuD3ds13wEeg52CIiIsFFoSqEPHAujLDAa4egqjnQrREREZHjKVSFkHEjDb6d4dlWb5WIiEhwUagKMSvOhVgLvHMEXjgQ6NaIiIhIL4WqEJMabfCf4zzbD/4TutVbJSIiEhQUqkLQvedAfAT8zQV/2B/o1oiIiAgoVIWkpCiDe872bBf+E7rUWyUiIhJwClUh6p6zISkS3m+D/2kIdGtEREREoSpExUca3HeOZ3vlP6GjW71VIiIigaRQFcK+Ow5So+GfR6FUc6tEREQCSqEqhMVFGHyrZ5X1pzUEKCIiElAKVSHu6z0PWt50EPa7NQQoIiISKApVIW5yrMHFZ0GXCb9rDHRrREREhi+FqjDw9VTPVw0BioiIBI5CVRhYOMZTyLcOw4dtGgIUEREJBIWqMJA2wsCW5NnWmlUiIiKBoVAVJo4fAjS1wrqIiMiQU6gKE/NTINYCe9ph65FAt0ZERGT4UagKE9ZIg/mjPdtP1Qe2LSIiIsORQlUY6R0C/F2jHlsjIiIy1BSqwogtEUZHwf4OqGoOdGtERESGF4WqMBJpMVg4xrOtTwGKiIgMLYWqMPP/9Ty2pmw/uDo1BCgiIjJUFKrCzMyzYFIMtHVDWVOgWyMiIjJ8KFSFGcMwuLVnwrqGAEVERIaOQlUY6v0U4OaD0ODWEKCIiMhQUKgKQxNjDb4UD93Ab9VbJSIiMiQUqsKUhgBFRESGlkJVmFo4BiIM2HYEPmjTEKCIiIi/BSRU1dTUkJOTg8PhIDc3l8bGxpOOaWxsJDc3F4fDQU5ODjU1Nd5927ZtY+7cudjtdhYvXkxraysAu3fvZv78+WRnZ3P99dfzk5/8xHtOV1cXBQUF2Gw2HA4Hmzdv9vt9BtLoaINrkzzb/6PH1oiIiPhdQEJVYWEheXl5VFRUkJWVRUlJyUnHlJSUkJWVRUVFBXl5eRQWFgLQ3d3NihUrWLVqFZWVlaSmprJhwwYAJk6cyO9//3vKy8spKyvjjTfe4PXXXwegrKyM/fv3U1lZyYYNG1i5ciUul2vobjoAeocAn24A01RvlYiIiD9FDvUbNjU1UVNTg91uB2DBggXMmjWLNWvWnHBcZWUlBQUFANjtdoqKijhw4AD79u0jPj6e6dOnA7Bw4UKWLl3KkiVLGDlypPf8Y8eO4Xa7vd9v2rSJW2+9FcMwGDduHDNmzOC1117juuuuG/C9tLe3D/jcoWCLBatlJB8dNXi18RiXntUd6Cb5XG8Ngr0Ww4FqETxUi+CiegQP0zQxDMNv1x/yUFVfX096err3pqxWK1FRUTQ3N5OYmAhAc3Mz0dHRWK1WwLP2UlpaGk6nE6fTydixY73Xy8jIwOl0er//5JNPWLx4MbW1tdxyyy18+ctf9r5vRkaG97j09HTq6wc3LlZbWzuo84fClRHn8qfuZNbtOUx8zN5AN8dvQqEWw4VqETxUi+CiegSH6Ohov117yEPV6Yahjk+OZzrmVPuOP/ecc87h+eefp6WlhbvvvputW7cyc+bMzzxvIMaPH09MTMygruFveS0W/vQBbDFTWD/ZSlSYfTShvb2d2trakKhFuFMtgodqEVxUj+CxZ88ev15/yENVbw9Rbxecy+Wio6ODhIQE7zFJSUm43W5cLhdWqxXTNGloaCAtLY2uri7q6uq8x9bV1ZGWlnbS+yQkJHDVVVfx0ksvMXPmTNLT03E6nUyePBkAp9PJhRdeOKh7iYmJITY2dlDX8LevjDRJ+yfUuw3+cjSGuSn+6/YMpFCoxXChWgQP1SK4qB6B58+hPwjARPWUlBQyMzOpqqoCoLS0FJvNdtJxNpuN0tJSAKqqqsjMzCQ5OZmpU6fS0tLC7t27Adi4cSMOhwOAvXv3eudRHT16lFdffZVJkyYB4HA42LhxI6ZpUldXx/bt25k9e7bf7zfQIi0GN4/xbGvNKhEREf8Z8p4qgKKiIvLz8ykuLmbMmDEUFxfT0NBAXl4e5eXlACxbtozly5fzzDPPEBcXx9q1awGwWCysXr2a/Px8Ojo6mDRpEkuXLgXg3XffZf369URERNDd3c3VV1/NwoULAZg/fz47duzAZrMRERFBQUGBd85WuPt6GvzkUyhvgiOdJmdFhmdvlYiISCAZpj5r32+7du3C7XYzZcqUkOjKNU2Tz70NNe3wh6lww+jwCVVtbW1UV1eHTC3CmWoRPFSL4KJ6BI+dO3diGAbTpk3zy/XDbNqynIphGFyf7Nn+04HAtkVERCRcKVQNE72h6qUDWghURETEHxSqhonZCRAXAU437AjvheRFREQCQqFqmBhhMbB51lbVEKCIiIgfKFQNI9f1zqtqCmw7REREwpFC1TDSG6q2HoFGt+ZViYiI+JJC1TCSMcJghhVMPBPWRURExHcUqoaZ3t6qFxWqREREfEqhapjpXVqh4iB0dGsIUERExFcUqoaZmfEwOgoOd8EbhwLdGhERkfChUDXMWAyDr2h1dREREZ9TqBqGNK9KRETE9xSqhiF7IkQYUN0GH7VrXpWIiIgvKFQNQwlRBl8e5dnWEKCIiIhvKFQNU9drCFBERMSnFKqGqd5Q9WoLtHZpCFBERGSwFKqGqfNjIXMkHOuGl5sD3RoREZHQp1A1TBmG8a8HLGsIUEREZNAUqoax3iHAlw6AaWoIUEREZDAUqoaxrASItcCnx2Bna6BbIyIiEtoUqoaxkREG1yR6tl9oCmxbREREQp1C1TB3fYrnq5ZWEBERGRyFqmHuuiTP17cOQ5Nb86pEREQGSqFqmBs30uBCK5jApoOBbo2IiEjoUqgSPWBZRETEBxSqxLu0wqaD0NmtIUAREZGBUKgSLo2H5Cho6YS/Hg50a0REREKTQpUQYRhc2zNh/QUNAYqIiAyIQpUA/xoC1LwqERGRgVGoEgAcSRBhwN9b4eOjmlclIiLSXwpVAkBilMHl8Z5tPWBZRESk/xSqxMu7tIIeWSMiItJvClXi1Tuv6pUWONqlIUAREZH+UKgSr8/HQVo0tHdraQUREZH+UqgSL8MwmJPo2a5qDmxbREREQo1ClZxgTs96VS/rOYAiIiL9olAlJ7imp6dq2xFo7tC8KhERkb5SqJITjB1hMCUWuvFMWBcREZG+UaiSk/QOAVZpCFBERKTPFKrkJL2T1V/WZHUREZE+U6iSk1yZ4HlkzZ52PbJGRESkrwISqmpqasjJycHhcJCbm0tjY+NJxzQ2NpKbm4vD4SAnJ4eamhrvvm3btjF37lzsdjuLFy+mtbUVgKqqKm644QbmzZvHV7/6VV588UXvOY8//jhXXHEF2dnZZGdns27dOv/faIiKjzS49CzPtoYARURE+iYgoaqwsJC8vDwqKirIysqipKTkpGNKSkrIysqioqKCvLw8CgsLAeju7mbFihWsWrWKyspKUlNT2bBhAwBjxozh5z//OX/84x9Zv349Dz30EA0NDd5r3nTTTZSXl1NeXs6iRYuG5mZDlHdpBQ0BioiI9EnkUL9hU1MTNTU12O12ABYsWMCsWbNYs2bNCcdVVlZSUFAAgN1up6ioiAMHDrBv3z7i4+OZPn06AAsXLmTp0qUsWbLE+xpAamoqycnJNDY2kpqa6pd7aW9v98t1g8GXYy3ACDYfNHG1tmMxAt2iU+utQTjXIlSoFsFDtQguqkfwME0Tw/Df/9CGPFTV19eTnp7uvSmr1UpUVBTNzc0kJnpmSDc3NxMdHY3VagU8K32npaXhdDpxOp2MHTvWe72MjAycTudJ77N161ZaW1uZPHmy97WysjK2bNnCuHHjuPfee5kwYcKg7qW2tnZQ5wezs0yI5UIOdEbw/N9rmRwR3H8ZhHMtQo1qETxUi+CiegSH6Ohov117yEOVaZ564vPxyfFMx5xq37+nzr1795Kfn09xcbH3N+/mm29m0aJFREZGUlZWxl133cXmzZsHehsAjB8/npiYmEFdI5jN/gA2tcDHyROZn94Z6OacUnt7O7W1tWFfi1CgWgQP1SK4qB7BY8+ePX69/pCHqvT0dOrr671dcC6Xi46ODhISErzHJCUl4Xa7cblcWK1WTNOkoaGBtLQ0urq6qKur8x5bV1dHWlqa9/uGhga+9a1v8eCDDzJjxgzv66NHj/Zuz58/n4cffpimpiZSUlIGfC8xMTHExsYO+Pxg50gx2dQCr7mi+K9Y/yV7Xwj3WoQS1SJ4qBbBRfUIPH8O/UEAJqqnpKSQmZlJVVUVAKWlpdhstpOOs9lslJaWAp5P9WVmZpKcnMzUqVNpaWlh9+7dAGzcuBGHwwHAwYMHueOOO/jud79LVlbWCdc7fsL6m2++SVRUFElJSf64xbDRO1n9tRY42qWlFURERM5kyHuqAIqKirzDc2PGjKG4uJiGhgby8vIoLy8HYNmyZSxfvpxnnnmGuLg41q5dC4DFYmH16tXk5+fT0dHBpEmTWLp0KQDr16/n008/5cknn+TJJ58EoKCggIsvvpiSkhKqq6sxDIPY2FieeOIJLBYt03UmF8RCejQ43fDXw3BVYqBbJCIiErwM83QTmOS0du3ahdvtZsqUKWHflfsf75n8pgH+61z40YTg+whgW1sb1dXVw6IWwU61CB6qRXBRPYLHzp07MQyDadOm+eX66qqRM7qmd70qLQIqIiJyRgpVckbX9Az5bTsCzR3q1BQRETkdhSo5o7EjDKbEQjfwSkugWyMiIhK8FKrkM/V+ClDPARQRETk9hSr5THN6hgCr9BxAERGR01Koks90ZQJEGPBhO9S2a16ViIjIqShUyWeKjzT4Urxn+2X1VomIiJySQpX0Se+nABWqRERETk2hSvrk+HlV3VovVkRE5CQKVdInl8aDNQKaOmCnK9CtERERCT4KVdInURaDrATPtj4FKCIicjKFKumz3nlVWq9KRETkZApV0me9i4D+5RAc7dK8KhERkeMpVEmfXRAL6dHQ3g1/PRzo1oiIiAQXhSrpM8MwtLq6iIjIaShUSb9co+cAioiInJJClfRL72T1bUeguUPzqkRERHopVEm/jB1hcEEsmMArLYFujYiISPBQqJJ+6x0C3KwhQBERES+FKum33iHALZqsLiIi4qVQJf12ZYLnD86edth7VPOqREREQKFKBmBUpMHMeM/2y+qtEhERARSqZICu1hCgiIjICRSqZEB651W93AymqSFAERERhSoZkMvjYaQFnG54vy3QrREREQk8hSoZkJERBleM8mxrCFBEREShSgZB86pERET+RaFKBqx3XtUrLdCleVUiIjLMKVTJgH3xLBgVCS2dsONIoFsjIiISWApVMmARhkFWgmdb61WJiMhwp1Alg3KV5lWJiIgAClUySL3zql4/BMe6Na9KRESGL4UqGZQLYiEtGtq74a+HAt0aERGRwFGokkExDMO7tILmVYmIyHCmUCWDpvWqREREFKrEB3rnVb1zBA53al6ViIgMTwpVMmjnjjQ4Lwa6TPhLS6BbIyIiEhgKVeITmlclIiLDnUKV+MQ1mlclIiLDnEKV+MRVCZ6vO1uh0a15VSIiMvwoVIlPjI42mB7n2X5FvVUiIjIMKVSJz2helYiIDGf9DlXHjh0b9JvW1NSQk5ODw+EgNzeXxsbGk45pbGwkNzcXh8NBTk4ONTU13n3btm1j7ty52O12Fi9eTGtrKwBVVVXccMMNzJs3j69+9au8+OKL3nO6urooKCjAZrPhcDjYvHnzoO9DTqR5VSIiMpz1O1Rdfvnl3HffffzlL3+hu7t7QG9aWFhIXl4eFRUVZGVlUVJSctIxJSUlZGVlUVFRQV5eHoWFhQB0d3ezYsUKVq1aRWVlJampqWzYsAGAMWPG8POf/5w//vGPrF+/noceeoiGhgYAysrK2L9/P5WVlWzYsIGVK1ficrkG1H45tdkJEGnAR0ehtl3zqkREZHiJ7O8JL7zwAn/605945JFHWLFiBddeey3z5s3joosu6tP5TU1N1NTUYLfbAViwYAGzZs1izZo1JxxXWVlJQUEBAHa7naKiIg4cOMC+ffuIj49n+vTpACxcuJClS5eyZMkS72sAqampJCcn09jYSGpqKps2beLWW2/FMAzGjRvHjBkzeO2117juuuv6+1vg1d7ePuBzw1EEcHFcNG+5Inipwc1/jOny+3v21kC1CDzVInioFsFF9QgepmliGIbfrt/vUJWens6dd97JnXfeyUcffcSf/vQn7r33XkzTZO7cueTk5HD22Wef9vz6+nrS09O9N2W1WomKiqK5uZnERM/4UXNzM9HR0VitVsDzfLm0tDScTidOp5OxY8d6r5eRkYHT6TzpfbZu3UprayuTJ0/2vm9GRsYJ91FfX9/f2z9BbW3toM4PR593p/MW6Ty/18UlB2qH7H1Vi+ChWgQP1SK4qB7BITo62m/X7neo6tXZ2cnHH39MbW0thw4d4otf/CIul4uFCxeycOFC7r777lOeZ5qnHhY6Pjme6ZhT7fv31Ll3717y8/MpLi72/ub15bz+Gj9+PDExMYO6Rri56bCFDdWww0jk/PNj8OM/CADPv/xqa2tViyCgWgQP1SK4qB7BY8+ePX69fr9D1datW/njH/9IRUUFEyZMYN68eRQUFJCQkADAXXfdhcPhOG2o6u0h6u2Cc7lcdHR0eM8HSEpKwu1243K5sFqtmKZJQ0MDaWlpdHV1UVdX5z22rq6OtLQ07/cNDQ1861vf4sEHH2TGjBknvK/T6fT2XDmdTi688ML+3v4JYmJiiI2NHdQ1wk3WSJOYD6Cxw6CWGD4f6+dU1UO1CB6qRfBQLYKL6hF4/hz6gwFMVC8oKCAtLY3S0lKeeeYZbr311hMC0ejRo1m2bNlpz09JSSEzM5OqqioASktLsdlsJx1ns9koLS0FPJ/qy8zMJDk5malTp9LS0sLu3bsB2LhxIw6HA4CDBw9yxx138N3vfpesrKwTrudwONi4cSOmaVJXV8f27duZPXt2f29fPsMIi8GsUZ5tLa0gIiLDSb9D1be//W2+853vnDRv6vnnn/duf/3rXz/jNYqKili3bh0Oh4OXX36ZZcuW0dDQQHZ2tveYZcuW8fLLL+NwOFi3bh0rV670NNhiYfXq1eTn52O323E6ndxxxx0ArF+/nk8//ZQnn3yS7OxssrOz2bZtGwDz588nMTERm83GbbfdRkFBgXfOlvjW1VpaQUREhiHDPN0EptOYMWMG27dvP+n1Sy65hHfeecdnDQtmu3btwu12M2XKFHXlnsK7R0xmboP4CGj6MkRa/Nfd2tbWRnV1tWoRBFSL4KFaBBfVI3js3LkTwzCYNm2aX67f5zlVvUGqu7ubHTt2nDDxe+/evZp8J14XWSEhElo64d0jcOmoQLdIRETE//ocqpYvXw54VlQ/fs6UYRikpKTwwAMP+L51EpIiDIOrEkyea/LMq1KoEhGR4aDPoWrLli0APPDAAzz00EN+a5CEh6sT4bkmz7yq748PdGtERET8r98T1RWopC96nwP4xmFo79Ija0REJPz1uadq/vz5lJWVYbfbT7vOQ0VFhc8aJqFtcixkREOdG948BNckBbpFIiIi/tXnUNU7Z0o9VdIXhmFwTaLJbxqgqlmhSkREwl+fQ9XFF18MeJZOOJ7b7cZisRAZOeAn3kiYmpOEN1Q9HOjGiIiI+Fm/51StWbOGXbt2AfDKK68wc+ZMZs6cySuvvOLzxklom9Mzr2r7EWhya16ViIiEt36HqrKyMiZNmgTA448/TklJCT//+c8pKSnxeeMktKWPMJgeByZ6ZI2IiIS/focqt9vNyJEj2b9/Pw0NDcyZM4dLLrnkhIcci/Sa0zOXqlKhSkREwly/J0JNnjyZX/ziF9TV1XHllVcC0NjYqKX35ZTsSfDIXth8EEzT9PsTwkVERAKl3z1Vq1at4v3336etrY3vfe97AOzYseOEhyGL9Jo1CkZY4NNj8EFboFsjIiLiP/3uqRo/fjyPPPLICa85HA4cDofPGiXhIybCYNYok6pmzxDg+XGBbpGIiIh/9DtUud1uysvL+eCDD2htbT1h38MP64PzcjJbkmdZhc0HYcm4QLdGRETEP/odqu677z4++ugjrrrqKpKTk/3RJgkz9iTIr4FXW8DdbRJt0bwqEREJP/0OVa+//jqvvvoqVqvVH+2RMDQtDsZEQWMH/PUQXJkY6BaJiIj4Xr8nqmdmZuJyufzRFglTFsPApqUVREQkzPW7p+rKK6/kzjvv5Kabbjpp+G/evHk+a5iEF1sS/E+DZ17VjyYEujUiIiK+1+9Q9fbbb5OYmMjLL798wuuGYShUyWnZeob83j0CBzpMkqM0r0pERMJLv0PVb37zG3+0Q8Jc+giDqXEmu1s9j6xZMCbQLRIREfGtfs+pAqipqeFnP/sZDz30EAC1tbX84x//8GnDJPx451UdDGw7RERE/KHfoerFF18kNzeXxsZGnn32WQCOHDnCj370I583TsKLvWcIsPeRNSIiIuGk36Hqscce41e/+hUPPvggERERAJx//vm8//77Pm+chJdZCRBtwN5j8I/2QLdGRETEt/odqg4dOsTEiRMBvA/HNU2TyMh+T8+SYSY2wmBWgmdbQ4AiIhJu+h2qZsyYwa9//esTXvvtb3/LF7/4RZ81SsKX7bghQBERkXDS7+6lBx98kEWLFvHb3/6WtrY2vvrVr2IYBr/4xS/80T4JM7YkWPGRHlkjIiLhp9+hKjU1leLiYg4ePMjWrVu57LLLmD59und+lciZXGiF0VGwvwPeOgyzEwLdIhEREd/oV6j63e9+x09+8hNaWloAz1yq3/zmNyxZsoRbbrnFH+2TMON5ZI3J0w2eeVUKVSIiEi76PKdqy5Yt/PjHP+Y73/kOVVVV/O1vf6OqqorvfOc7PProoyetsC5yOnN65lVVaV6ViIiEkT73VD311FPk5+fzta99zfvauHHj+MY3vsHIkSN56qmnuOaaa/zSSAkvvYuAbj0CBztMkvTIGhERCQN97ql67733mDNnzin32Ww23nvvPZ81SsLb2BEGn48DE88ja0RERMJBn0OV2+0mMTHxlPsSEhLo6OjwWaMk/PUOAWq9KhERCRd9Hv7r7u5mx44dp328iB47Iv1hT4LHPoWqZs+fnd6FZEVEREJVn0NVUlISy5YtO+3+0/ViiZzK7ATPI2s+Pgp72uFzsYFukYiIyOD0OVRt2bLFn+2QYSYuwuCKUSavtHiGABWqREQk1PX7MTUivtL7KcAqTVYXEZEwoFAlAWPvCVVbmqGjW3PyREQktClUScBcZIWUKHB1eR5ZIyIiEsoUqiRgLIbhXVphs5ZWEBGREKdQJQHVO69qs+ZViYhIiFOokoCy9fRUbT3seWSNiIhIqApIqKqpqSEnJweHw0Fubi6NjY0nHdPY2Ehubi4Oh4OcnBxqamq8+7Zt28bcuXOx2+0sXryY1tZW73VvueUWLrroIpYvX37C9R5//HGuuOIKsrOzyc7OZt26df69SemTcSMNLoiFbjQEKCIioS0goaqwsJC8vDwqKirIysqipKTkpGNKSkrIysqioqKCvLw8CgsLAc/K7itWrGDVqlVUVlaSmprKhg0bAM/jcvLz88nPzz/l+950002Ul5dTXl7OokWL/HeD0i9fSfZ8/dOBwLZDRERkMPq8+KevNDU1UVNTg91uB2DBggXMmjWLNWvWnHBcZWUlBQUFANjtdoqKijhw4AD79u0jPj6e6dOnA7Bw4UKWLl3KkiVLSE5OJjk5mY8++mhI7qW9vX1I3ifc2awWShjBiwdMjrS2E9GPJ9b01kC1CDzVInioFsFF9Qge/n4s2pCHqvr6etLT0703ZbVaiYqKorm52fuom+bmZqKjo7FarQAYhkFaWhpOpxOn08nYsWO918vIyMDpdPbpvcvKytiyZQvjxo3j3nvvZcKECYO6l9ra2kGdLx6jTIhnOgc7I9m4+xMuimzt9zVUi+ChWgQP1SK4qB7BITo62m/XHvJQdboHLx+fHM90zKn29SV13nzzzSxatIjIyEjKysq466672Lx5cx9bfWrjx48nJiZmUNcQj2s/hI0H4L1RE7jlnM4+n9fe3k5tba1qEQRUi+ChWgQX1SN47Nmzx6/XH/JQlZ6eTn19vbcLzuVy0dHRQUJCgveYpKQk3G43LpcLq9WKaZo0NDSQlpZGV1cXdXV13mPr6upIS0v7zPcdPXq0d3v+/Pk8/PDDNDU1kZKSMuB7iYmJITZWD63zhfmpJhsPQMWhKEpi+/+vCNUieKgWwUO1CC6qR+D5c+gPAjBRPSUlhczMTKqqqgAoLS3FZrOddJzNZqO0tBSAqqoqMjMzSU5OZurUqbS0tLB7924ANm7ciMPh+Mz3bWho8G6/+eabREVFkZSU5ItbEh9wJEGEAe+1wUftWlpBRERCz5D3VAEUFRWRn59PcXExY8aMobi4mIaGBvLy8igvLwdg2bJlLF++nGeeeYa4uDjWrl0LgMViYfXq1eTn59PR0cGkSZNYunQpAAcPHmT+/PkcPXoUt9vN7NmzKSgowGazUVJSQnV1NYZhEBsbyxNPPIHFomW6gkVilMGsUSavtsALB2DJuEC3SEREpH8M83QTmOS0du3ahdvtZsqUKerK9aGST0zurYE5iVB5Ud+6aNva2qiurlYtgoBqETxUi+CiegSPnTt3YhgG06ZN88v11VUjQWNez/S2P7fA4U5lfRERCS0KVRI0PhdrMCkGOkyo1OrqIiISYhSqJKjM7emt0urqIiISahSqJKjMPe6RNV2a7iciIiFEoUqCypdHwahIaOqAtw8HujUiIiJ9p1AlQSXKYvCVnuXDXmgKbFtERET6Q6FKgs71PUOAL2helYiIhBCFKgk6X0n2/MHc3Qq1Wl1dRERChEKVBJ2kKIMrRnm21VslIiKhQqFKgpKWVhARkVCjUCVBqXdphVea4YhWVxcRkRCgUCVB6fxYOC8G3CZUNQe6NSIiIp9NoUqCkmEY3k8B/lFLK4iISAhQqJKgNa8nVL14ALq1urqIiAQ5hSoJWrMSID4CGjtgq1ZXFxGRIKdQJUEr2mLg6Fld/Y/6FKCIiAQ5hSoJalpaQUREQoVClQS1ryR5/pD+zQWfHNW8KhERCV4KVRLUUqINLutZXV29VSIiEswUqiToeR+wrKUVREQkiClUSdCb1zOvaksLtHZpCFBERIKTQpUEvQtiYfxIONYNVQcD3RoREZFTU6iSoGcYhvdZgC9oXpWIiAQphSoJCccvraDV1UVEJBgpVElIuDLBs7p6vRvePBTo1oiIiJxMoUpCwgiLwQ2jPdu/bQxsW0RERE5FoUpCxsIxnq+ljdDZrSFAEREJLgpVEjKuSYTkKM8Dll9tCXRrRERETqRQJSEjymKQoyFAEREJUgpVElJu7hkCfHY/uDUEKCIiQUShSkLKrARIj4aWTqjUQqAiIhJEFKokpEQYBl/r6a3SEKCIiAQThSoJOb1DgOVN0NYV2LaIiIj0UqiSkHNpPJw7Elq7YFOL/giLiEhw0P+RJOQYhvGvNasORAa2MSIiIj0UqiQk9Q4BVrRYcJn6YywiIoGn/xtJSLrQCufHwjHT4LWOhEA3R0RERKFKQtPxQ4CVnYmBbYyIiAgKVRLCekPVW53xHOgIbFtEREQUqiRknR9nMD22my4Mnm+OCHRzRERkmFOokpB2U7JnoarSAwpVIiISWAEJVTU1NeTk5OBwOMjNzaWx8eSlsRsbG8nNzcXhcJCTk0NNTY1337Zt25g7dy52u53FixfT2trqve4tt9zCRRddxPLly0+4XldXFwUFBdhsNhwOB5s3b/bvTcqQyOkJVa8dtuA8pmcBiohI4AQkVBUWFpKXl0dFRQVZWVmUlJScdExJSQlZWVlUVFSQl5dHYWEhAN3d3axYsYJVq1ZRWVlJamoqGzZsACAhIYH8/Hzy8/NPul5ZWRn79++nsrKSDRs2sHLlSlwul39vVPzu3BEm0yJcmBiU7g90a0REZDgb8pUTm5qaqKmpwW63A7BgwQJmzZrFmjVrTjiusrKSgoICAOx2O0VFRRw4cIB9+/YRHx/P9OnTAVi4cCFLly5lyZIlJCcnk5yczEcffXTS+27atIlbb70VwzAYN24cM2bM4LXXXuO6664b8L20t7cP+Fzxjfb2dmyRrezqsvKMs4s7ktyBbtKw1fvzoJ+LwFMtgovqETxM08QwDL9df8hDVX19Penp6d6bslqtREVF0dzcTGKi56Pxzc3NREdHY7VaAc/H59PS0nA6nTidTsaOHeu9XkZGBk6ns0/vm5GR4f0+PT2d+vr6Qd1LbW3toM4X35gTFcWjx8bxliuCLX+vId2iYBVI+rkIHqpFcFE9gkN0dLTfrj3koco0Tz3v5fjkeKZjTrWvL6lzoOedyfjx44mJiRnUNWRw2tvbobaWy+M6eaM1ip2Jk7k6ozPQzRqW2tvbqa2t1c9FEFAtgovqETz27Nnj1+sPeajq7SHq7YJzuVx0dHSQkJDgPSYpKQm3243L5cJqtWKaJg0NDaSlpdHV1UVdXZ332Lq6OtLS0vr0vk6nk8mTJwPgdDq58MILB3UvMTExxMbGDuoa4hsLRpu80Qp/aI7i+xP9968Q+Wz6uQgeqkVwUT0Cz59DfxCAieopKSlkZmZSVVUFQGlpKTab7aTjbDYbpaWlAFRVVZGZmUlycjJTp06lpaWF3bt3A7Bx40YcDsdnvq/D4WDjxo2YpkldXR3bt29n9uzZPrwzCaTspC4iDdjhgg/a9ClAEREZegH59F9RURHr1q3D4XDw8ssvs2zZMhoaGsjOzvYes2zZMl5++WUcDgfr1q1j5cqVngZbLKxevZr8/HzsdjtOp5M77rgDgIMHDzJ79mxWr15NVVUVs2fP9i6dMH/+fBITE7HZbNx2220UFBR452xJ6EuJAlvP02p+1xDYtoiIyPBkmKebwCSntWvXLtxuN1OmTFFXboC1tbVRXV3NlClTKD0cwzerPQ9a/vsl/u/mlRMdXwv9XASWahFcVI/gsXPnTgzDYNq0aX65vlZUl7CRnQIjLPB+G+xqDXRrRERkuFGokrAxKtLguiTP9m81BCgiIkNMoUrCysJUz9enG6BLI9siIjKEFKokrHw1GZIi4ZNj8OKBQLdGRESGE4UqCSsjIwxuS/dsr9sX2LaIiMjwolAlYefbPU8x2nQQato1BCgiIkNDoUrCznkxBtf2TFj/mXqrRERkiChUSVha1NNb9SsntHept0pERPxPoUrC0nXJcM4IONgJv98f6NaIiMhwoFAlYSnCMLirp7dKE9ZFRGQoKFRJ2LojHaIMePswvHtEQ4AiIuJfClUStsZEG3xtjGdbvVUiIuJvClUS1hZleL4+0wDNHeqtEhER/1GokrB2+SiYHgft3fD/6gPdGhERCWcKVRLWDMPwLga6bh9063mAIiLiJwpVEva+ngpnRcCedtjSHOjWiIhIuFKokrB3VqTBN9I825qwLiIi/qJQJcNC7wrrzx+AT49qCFBERHxPoUqGhc/HGVyZAF0mrHcGujUiIhKOFKpk2OjtrVpfBx3d6q0SERHfUqiSYWN+CqRFQ70bypoC3RoREQk3ClUybERbDO5M92xrwrqIiPiaQpUMK3kZEGHAqy3wXquGAEVExHcUqmRYGTfS4KvJnm31VomIiC8pVMmw0zth/df14OpUb5WIiPiGQpUMO1cnwqQYONIFTzUEujUiIhIuFKpk2LEYhre36sefgFvLK4iIiA8oVMmw9K0MSI2Gfx6FX2kxUBER8QGFKhmW4iIMvn+uZ/uhj+Fol3qrRERkcBSqZNjKy4CzR8C+Y7CuLtCtERGRUKdQJcPWCItBwXjP9uqP9UlAEREZHIUqGdb+Iw0mxsD+Dvjpp4FujYiIhDKFKhnWoiwGheM928V7oaVDvVUiIjIwClUy7N2cCp+Pg5ZOKNkb6NaIiEioUqiSYS/CMFiZ6dl+7FPY71ZvlYiI9J9ClQhwQwrMsIKrC9Z8EujWiIhIKFKoEgEMw+CHEzzb/3cf1B1Tb5WIiPSPQpVIj2uT4IpRcLQbfvRxoFsjIiKhRqFKpIdhGPywZ27Vk3VQ267eKhER6TuFKpHjZCUazEmEDhN+UBvo1oiISChRqBL5N729Vb+uhw/a1FslIiJ9E5BQVVNTQ05ODg6Hg9zcXBobG086prGxkdzcXBwOBzk5OdTU1Hj3bdu2jblz52K321m8eDGtra3efU8//TQ2m405c+bw2GOPeV9//PHHueKKK8jOziY7O5t169b59yYlZF06ymBeMnQDK/8Z6NaIiEioCEioKiwsJC8vj4qKCrKysigpKTnpmJKSErKysqioqCAvL4/CwkIAuru7WbFiBatWraKyspLU1FQ2bNgAwCeffMKTTz5JaWkpL774In/+85956623vNe86aabKC8vp7y8nEWLFg3NzUpI6l236reNsNOl3ioREflsQx6qmpqaqKmpwW63A7BgwQIqKytPOq6yspIFCxYAYLfbqamp4cCBA+zevZv4+HimT58OwMKFC9m0aRMAFRUVOBwORo0aRXR0NDfeeKN3n0h/XHSWwYIxnu0H1VslIiJ9EDnUb1hfX096ejqGYQBgtVqJioqiubmZxMREAJqbm4mOjsZqtQKeT2WlpaXhdDpxOp2MHTvWe72MjAycTqf32uPHj/fuS09P5/XXX/d+X1ZWxpYtWxg3bhz33nsvEyZMGNS9tLe3D+p8GbzeGvijFvlpBqWNI3i+yeCVhqNcela3z98jnPizFtI/qkVwUT2Ch2ma3vzhD0Meqkzz1EMpx9/kmY451b7ec093HsDNN9/MokWLiIyMpKysjLvuuovNmzf3p+knqa2tHdT54jv+qsX1Uefwx44U7ny/m9/Evc8IQ0OBn0U/F8FDtQguqkdwiI6O9tu1hzxUpaenU19f702LLpeLjo4OEhISvMckJSXhdrtxuVxYrVZM06ShoYG0tDS6urqoq6vzHltXV0daWpr32sfvczqd3n2jR4/2vj5//nwefvhhmpqaSElJGfC9jB8/npiYmAGfL4PX3t5ObW2t32rxfzrg7V0m/+yI4VnrVH5wTqfP3yNc+LsW0neqRXBRPYLHnj17/Hr9IQ9VKSkpZGZmUlVVhc1mo7S0FJvNdtJxvfu++c1vUlVVRWZmJsnJySQmJtLS0sLu3buZOnUqGzduxOFwAJ65V7fddhuLFi1i5MiRlJWVsWzZMgAaGhpITU0F4M033yQqKoqkpKRB3UtMTAyxsbGDuob4hr9qEQv8fLLJDbvhJ84obkqP4kuj/Nd1HA70cxE8VIvgonoEnj+H/iAAoQqgqKiI/Px8iouLGTNmDMXFxTQ0NJCXl0d5eTkAy5YtY/ny5TzzzDPExcWxdu1aACwWC6tXryY/P5+Ojg4mTZrE0qVLATj33HO5/fbbufHGGwG4/vrrueyyywDPpwmrq6sxDIPY2FieeOIJLBYt0yWfLXu0wTdSTX7TAN+shh0zTWIiFKxEROREhnmmiUhySrt27cLtdjNlyhT9qyPA2traqK6u9nstmjtMpr0DdW6452womahQ9e+Gqhby2VSL4KJ6BI+dO3diGAbTpk3zy/XVVSPSB4lRBr8437P9k73wlxb9W0RERE6kUCXSR9clG9yWDiZw+/vQ2qVgJSIi/6JQJdIPj0yEs0dATTv8V81nHy8iIsOHQpVIP4yKNHiyZxjw/+yDV5rVWyUiIh4KVSL9ZEsyyMvwbN/xPhzpVLASERGFKpEB+fF5MH4k1B6F+zQMKCIiKFSJDMhZkQYbeoYBf14Hmw+qt0pEZLhTqBIZoKsSDb7b82zvO9+HQxoGFBEZ1hSqRAZh9XlwXgzsPQbLPgx0a0REJJAUqkQGIS7C4JfngwH80glP1qm3SkRkuFKoEhmkWQkGD4z3bH/7Ayjbr2AlIjIcKVSJ+EDReLgjHbqBW96D1/QYGxGRYUehSsQHDMNg3ecgOwWOdUP2LtjpUrASERlOFKpEfCTSYvD0BTBrFBzqhK/8Df7ZrmAlIjJcKFSJ+FBMhEH5NJgWB043XPs32O9WsBIRGQ4UqkR8LCHK4KUL4dyRsKcdrt+pR9mIiAwHClUifpAxwqDiQkiJgm1H4Kbd4O5WsBIRCWcKVSJ+8rlYgz9Nh7gI2NwMt1VDt6lgJSISrhSqRPxoZrzBH6ZCpAHPNMI9H4KpYCUiEpYUqkT8zJ5k8N9TPNuPfwoPfaxgJSISjhSqRIbArakGj0z0bBf+E257H9q7FKxERMKJQpXIEFl6tkHJRM8P3a/r4cvboVbrWImIhA2FKpEhdM/ZBpUXeT4VuMMFF2+DzQcVrEREwoFClcgQuzrRYNvFMPMsONiz8vrqj03NsxIRCXEKVSIBcM5Igz9/AW7veQjz9z+Cr/1di4SKiIQyhSqRABkZYfDk+QY/mwxRBjy7Hy59F95vVbASEQlFClUiAZaX4em1GjsC3m/zBKuy/QpWIiKhRqFKJAh8aZRnntXsUXCkC27cDf/5D5MmPYxZRCRkKFSJBInUaIPNF8Hd4zzfP7EPJr0Naz42taaViEgIUKgSCSJRFoNHJxlsvhAussKhTvivj+D8t+HX9aaeHSgiEsQUqkSC0DVJnuHA/zcFzh4Be4/BN6vhi1rXSkQkaClUiQQpi2HwjTSDDy6F1RNgVCT8zQWOv8G1/2vyN5fClYhIMFGoEglyIyMM7jvX4MMveeZbRRlQ2QwztsJt1Sa7FK5ERIKCQpVIiEiO8sy3qr4Ubh4DJvD/6uHCrXDxVpPH9prs16cFRUQCRqFKJMRMiDF4+vMGb30Rbkjx9Fxtd8E9H8LYN2H+LpNn95u4uxWwRESGkkKVSIi6JN7gD9MM9l0OP50EF58FnSY83wQ37YaMN2DxP0y2HtZzBUVEhoJClUiIS4k2WDzO4J2LDXZfAveeAxnRnoc1/999nhXaL3jHs5jo7xtNGjREKCLiF5GBboCI+M4FcQZrzoNVE0xeboZf18Nz++GDNs+vJ/Z5jjs/1mR2AsxOgCsTYOwII4CtFhEJDwpVImEowjCwJ4E9CQ53mmw+CH9ugddaYGer5xmD77fBL+o8x58X4wlZl8XDBXEwJRYSoxS0RET6Q6FKJMzFRxrkjIGcMZ7vD3aY/KUFXjvkCVk7jkBNu+fXr5z/Oi812mRKLJwfC1N6gtaUOM/QomEocImI/DuFKpFhJinKIHs0ZI/2fH+o0+SNQ56erP89AtVt8OkxaHB7fr3acuL58RGQGWMyNhoyRsDYEZ6vKVg42hVDSgecY5oKXiIy7ChUiQxzoyINrkuG65L/9dqRTpP32zwBq7pnuLC6FWqOwuEuz8rufzvpSiOAKbAdog3IGGGSEgVJkZAYBYk9X5MiIann+96vZ0WAtefXCIt6wkQkNAUkVNXU1HDffffhcrlITU2luLiYMWPGnHBMY2Mjy5cvp6GhAavVytq1aznvvPMA2LZtG0VFRbjdbj73uc+xZs0a4uLiAHj66af51a9+hWmazJs3j7vvvhuArq4uioqKeOutt7BYLCxfvhybzTa0Ny4SIs6KNJgZDzPjT3z9WLfJh+3wyVHYd8zzq84Ndcdgb3s3n7Z3cdCMwm1C7VHPr/6KNMAaYXpDljXCE7riImCkxRO6Rlj+tT3yuF/Hfz/COMM+C0RbPO8VZXi+Hr+tUCciAxGQUFVYWEheXh4Oh4Nf/vKXlJSUsGbNmhOOKSkpISsri9tvv52KigoKCwt56qmn6O7uZsWKFTzyyCNMnz6dH/7wh2zYsIElS5bwySef8OSTT/Lcc88RExPDzTffzKWXXsqXvvQlysrK2L9/P5WVlezbt4+bb76Zyy67DKvVGojfApGQNMJi8Pk4+Hzcyfva2o5RXV3NeZOncDgyhn3H4EAHNHfCwQ7PEg/Np/j+YCe4uuBot+c6nSa0dHp+BYoF0xOyLCcHrlN9f9K+M5xnGJ61bCwGRPR8tZzia4TxGfv+/fXjrtfpjqDBncw7jRGMHGHSGxENPO/v3R7E6/TsO+FYP7x+/PsF2kAXIzl61MInnVYaDlkYecw3S5oEy9JzQdIMbzu8X81TvAYkd0NshP/aYZhDvCpgU1MT8+bN480338QwDFwuF7NmzWLHjh0nHPeFL3yBv/zlL1itVkzT5PLLL+eFF15g3759FBUV8eyzzwLwj3/8g6VLl/Liiy+yfv16Dh48SH5+PgBPPfUUH374IUVFRXzrW9/i1ltv5aqrrgJgyZIlXHvttVx33XX9voft27djmiaRkZH6F22AmaZJZ2enahEEBlsLE89fhN092909fyl2/9vrvcf96y9Kg+6eC5inOOZMr4nI8JJquImyGMyYMcMv1x/ynqr6+nrS09O9f+larVaioqJobm4mMTERgObmZqKjo729SIZhkJaWhtPpxOl0MnbsWO/1MjIycDqd3muPHz/euy89PZ3XX3/duy8jI+OEffX19QO6h962WyxaOzXQDMMgOjo60M0QBl8Lo+c/fvxHpIgMcx0dhl//AT7koep0HWPH3+SZjjnVvt5zz9Tpdqbz+usLX/jCgM4TERGR8DXkXS29PUS9IcflctHR0UFCQoL3mKSkJNxuNy6XC/AEooaGBtLS0sjIyKCurs57bF1dHWlpad5rH7/P6XSesK+3R6t3X2pqqt/uU0RERIaXIQ9VKSkpZGZmUlVVBUBpaekpP4Vns9koLS0FoKqqiszMTJKTk5k6dSotLS3s3r0bgI0bN+JwOACw2+1UVFRw+PBh3G43ZWVl3n0Oh4ONGzdimiZ1dXVs376d2bNnD8Uti4iIyDAw5BPVAfbs2UN+fj6tra2MGTOG4uJiAPLy8igvLwegoaGB5cuX09jYSFxcHGvXrmXixIkAbN26laKiIjo6Opg0aRJr1qzxzr966qmn+O///m8Arr/+eu655x4AOjs7KSws5O233yYiIoLvfe973sAlIiIiMlgBCVUiIiIi4UYfXxMRERHxAYUqERERER9QqBIRERHxAYUqERERER9QqBIRERHxAYUqERERER9QqBIRERHxAYUqERERER9QqOqnmpoacnJycDgc5Obm0tjYGOgmhbXm5mbuvPNOrr32WubNm8f999+P2+0GYPPmzTgcDmw2GwUFBXR1dXnPe+yxx5gzZw42m42nn346UM0PW/fffz+TJ0+ms7MTUC0C4ejRozzwwAM4HA6+8pWv8NhjjwGqRSD8+c9/Zv78+WRnZ3PjjTeybds2QLUYKt///veZNWvWCX8nwcB+/1tbW1m8eDF2u525c+fy7rvv9q8xpvTL17/+dXPTpk2maZrmhg0bzPvuuy/ALQpvzc3N5jvvvGOapml2dXWZ99xzj7l+/XrzyJEj5hVXXGHu3bvX7O7uNr/97W+bpaWlpmma5l//+lfzhhtuMI8dO2a2tLSYV111lfnxxx8H8jbCyptvvmnm5+ebn/vc58yOjg7VIkCKiorMRx991Pt9Y2OjahEgl19+ublnzx7TNE1zy5YtZnZ2tmoxhN5++21z//793r+TTNMc8O//Y489Zv7gBz8wTdM0d+7caV5zzTVmV1dXn9uinqp+aGpqoqamBrvdDsCCBQuorKwMcKvCW0JCAjNnzgTAYrEwdepU6urqeO2115gxYwbjxo3DMAwWLFjApk2bANi0aRM33ngj0dHRjBo1CofDQUVFRSBvI2y0tbXxyCOPkJ+f731NtRh6ra2tvPTSS3znO9/xvjZ69GjVIoCOHDni/ZqamqpaDKFLLrmElJSUE14b6O//pk2bWLhwIQDTpk0jPj6e3bt397ktClX9UF9fT3p6OoZhAGC1WomKiqK5uTnALRsejh07xnPPPUdWVhb19fVkZGR496Wnp1NfXw9wxn0yOI888gi5ubkkJiZ6X1Mtht7evXtJSkrixz/+MTfeeCO33XYb1dXVqkWAPProoyxatIisrCyKi4t54IEHVIsAG+jvv9PpPGFfRkYGTqezz++rUNUP5mmePd0bssR/uru7yc/P50tf+hKzZ88+bS3g1HVSjQZv+/btfPLJJ8ybN++E11WLodfZ2UlNTQ2XXHIJzz77LLm5uXz3u99VLQKgq6uLn/3sZzz55JO8+uqrFBUVsXjxYrq7u097jmrhf778WehPbRSq+qE3zfYWxOVy0dHRQUJCQmAbNgysXLmSyMhIvv/97wOeWtTV1Xn3O51O0tLSvPuO/5eF0+kkNTV1aBschrZt28Z7773H1VdfzdVXXw2A3W4nOTlZtRhi6enpxMTEYLPZALjqqqtwuVz6uQiA9957j5aWFqZOnQrA1VdfTV1dHRkZGapFAA30Z+Hf99XV1XnP6wuFqn5ISUkhMzOTqqoqAEpLS71/qYn/rF27loaGBlavXu39F8Ps2bPZvn07+/btwzRNfv/73+NwOABwOBw899xzuN1uDh8+TEVFhXefDFxeXh6vv/46W7ZsYcuWLQBUVlYyZ84c1WKIJScnM23aNO8nk3bu3MnIkSOZNWuWajHE0tLS2Lt3L59++ing6dGNjo5WLQJsoP+PcDgc/O53vwPg73//O4cOHfIG5r6I9P2thLeioiLy8/MpLi5mzJgxFBcXB7pJYW3Pnj1s2LCBCRMmkJOTA8Dll19Ofn4+DzzwALfffjtdXV1ceumlzJ8/H4DLLruMK664guuuuw6AO+64g3POOSdQtxD2rFarahEAK1eu5P7778flcjFy5Eh++tOfctZZZ6kWQ2z06NHcf//9fPvb38ZisRAZGcmjjz6qWgyhe++9l7fffhvw9BRefPHFPPLIIwP6/b/jjju47777sNvtREdHs2bNGiyWvvc/GeaZBh5FREREpE80/CciIiLiAwpVIiIiIj6gUCUiIiLiAwpVIiIiIj6gUCUiIiLiAwpVIiIiIj6gUCUiIiLiAwpVIiIiIj6gUCUiIiLiAwpVIiIiIj7w/wPfnbPeEhHF1gAAAABJRU5ErkJggg==",
      "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": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions, losses = predict(model, train_dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_array = np.array(losses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "stdev = np.std(loss_array)\n",
    "mean = np.mean(loss_array)\n",
    "THRESHOLD = mean + stdev * 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check on test_normal_dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of intervals exceeding std dev loss: 28/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 std dev loss: {exceed_count}/{len(test_normal_dataset)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check on test_anomaly_dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of intervals exceeding std dev loss: 214/1000\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": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_prediction(data, model, title, ax, picker):\n",
    "    predictions, pred_losses = predict(model, [data])\n",
    "\n",
    "    ax.scatter(range(60), data[:,picker], label='true')\n",
    "    ax.scatter(range(60), predictions[0].reshape(60,5)[:,picker], label='reconstructed')\n",
    "    ax.set_title(f'{title} (loss: {np.around(pred_losses[0], 2)})')\n",
    "    ax.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "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",
    "picker = 4\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], picker=picker)\n",
    "\n",
    "for i, data in enumerate(sampled_test_anomaly_dataset):\n",
    "    plot_prediction(data, model, title='Anomaly', ax=axs[1, i], picker=picker)\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": 101,
   "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 ,seq_len) ]\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": 127,
   "metadata": {},
   "outputs": [],
   "source": [
    "_, losses = predict(model, test_anomaly_dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [],
   "source": [
    "anomaly_flag_prediction = [ l > THRESHOLD for l in losses ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "214"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(np.array(anomaly_flag_prediction))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [],
   "source": [
    "result_mat = confusion_matrix(anomaly_flag_actual, anomaly_flag_prediction)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[759 172]\n",
      " [ 27  42]]\n"
     ]
    }
   ],
   "source": [
    "print(result_mat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42 27 172 759\n",
      "786\n",
      "214\n"
     ]
    }
   ],
   "source": [
    "tn, fp, fn, tp = result_mat.ravel()\n",
    "print(tp, fn, fp, tn)\n",
    "print(tn + fn )\n",
    "print(fp + tp)\n",
    "\n",
    "#                     actual negative actual positive \n",
    "# predicted negative: tn fp\n",
    "# predicted positive: fn tp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8152524167561761\n",
      "0.6086956521739131\n",
      "0.801\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": 135,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "only 19.626168224299064 of flagged intervals are actual\n"
     ]
    }
   ],
   "source": [
    "print(f\"only {tp / (fp + tp) * 100} of flagged intervals are actual\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6086956521739131"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tp / (fn + tp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## plot regions of predicted anomalies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### juxtapose over anomalous region"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [],
   "source": [
    "_, losses = predict(model, test_anomaly_dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [],
   "source": [
    "anomaly_flag_prediction = [ l > THRESHOLD for l in losses ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_segments = []\n",
    "count = 0\n",
    "for i in anomaly_flag_prediction:\n",
    "    count = count + 1\n",
    "    x_segments.append([count*60, count*60 + 60])\n",
    "y_segments = [ [0,0] for i in x_segments]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjEAAAGcCAYAAAAoBfFZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAArqUlEQVR4nO3df3BT54Hu8ecYJLDxEn64WIZki4sdh3spCdmQ3XbrhNDa6m5YIJDiZpgy0wnxNjOMy4aCGdrEJrlhILHLzf4RZpIlk0ymzYQ6EJVlAq5Jh7azbRo27HbJuB0s1t0klkzta0iFhC3sc/+gqBjLv49svTrfzz/C57x69T46In5yJB0s27ZtAQAAGCZrshcAAAAwFpQYAABgJEoMAAAwEiUGAAAYiRIDAACMRIkBAABGosQAAAAjTZ3sBaTSmTNnZNu2PB7PZC8FAACMUDwel2VZWrZs2ZDjMvpMjG3bSsW1/GzbVk9PT0rmTndkd192t+aWyO7G7G7NLaVX9pH+/s7oMzHXz8B8/vOfd3TeaDSq5uZmFRUVKScnx9G50x3Z3Zfdrbklsrsxu1tzS+mV/b/+679GNC6jz8QAAIDMRYkBAABGosQAAAAjUWIAAICRKDEAAMBIlBgAAGAkSgwAADASJQYAABiJEgMAAIxEiQEAAEbK6H92wGThK7aWnZYuXpVmTZXO3CP5pluSpEtxW6t+I/2+W/rsNOlfl0q3eKwRz91r2/r5Rem/o9IrYenSVWlRtvT6/5Jyp/55np4+W3X/LX3/f6T/l9g6TdJdmvGeVDLd1rkr0h+HebzPTJH+894/rx8AACdQYtJQ7ilb0b4//9wel+b/UsrJslXglYJX/rzv425p9i+kRdNtnfvC8CXh8B9sbT137X43OhuVZv5cuifX1q+XW9rRYqvuo2QzXDt5d1nSB1eS7R/oD71/Xn/kfooMAMAZjr+dtGvXLpWWlqqkpERXr15NOubChQvatGmT/H6/1q9fr2AwmNh3+vRprVq1SuXl5dqyZYsuX77s9BLT2s0F5kbRvv4F5kbBK1LxL4f+Fz8P/8HW184OLDA3Oh2RCn4xWIEZn2jftXwAADjB8RKzdu1aHTlyZMgx9fX1WrFihU6cOKHKykrV1NRIkvr6+rRz507t2bNHjY2Nys/P18GDB51eYtoKXxm8wIxE8Mq1t5qS6bWvnYEZSYVoj499DcOJ9l3LCQDAeDn+dtK999477JjGxkY9+eSTkqTy8nLV1taqs7NTn3zyiWbOnKmlS5dKkioqKrR161ZVVVWNeT22bSsajY75/snEYrF+t06567RX0pRxzfF3Z3rVtKRnwPaffZqlj7unjWtup9z1616dv2fgGtNdqo57unNrbonsN966hVtzS+mV3bZtWdbwHz+Y8M/EdHV1yev1Kjc3V5JkWZZ8Pp9CoZBCoZAWLFiQGDt//nyFQqFxPV48Hldzc/O45hhMa2uro/N19d457jnOX76aNO8H8dmSCsc9vxO6epWyYzIRnD7upnBrbonsbuTW3FL6ZPd6vcOOmfASY9vJ30qwLCvpvpE0saF4PB4VFRWNa46bxWIxtba2auHChcrOznZs3tmnpQu945vjczOmavHixQO2/+HTLClNesPsKUq6xnSXquOe7tyaWyK7G7O7NbeUXtlbWlpGNG7CS8ycOXPU09OjSCSi3Nxc2bat9vZ2+Xw+9fb2qq2tLTG2ra1NPp9vXI9nWZZycnLGu+yksrOzHZ37P+61Nf+X45vjnWVTlOMZuKaybFu3nh/6Q70T5T/unaKc6ak5JhPB6eNuCrfmlsjuxuxuzS2lR/aRnsCYlIvdlZWVqaGhQZLU1NSkwsJCzZ07V0uWLNHFixd19uxZSdKhQ4fk9/snY4mTwjfdUs44jsii6YNfL2aKZen/FksjeVnke8a+huHkZHG9GACAMxwvMdu3b9d9990nSVq5cqWeeOIJtbe3a82aNYkx27Zt08mTJ+X3+3XgwAHt3r372mKysrR3715VV1ervLxcoVBIjz76qNNLTGuR+wcvMjlZ14pKMouma9jrxKz7jKUfLZFuHeLzvffkSqEvWfrObSNc8CjkZInrxAAAHOP420nPP/980u2BQCDx5/z8fL3++utJxy1fvlzHjh1zellGidxvpeyKves+Y2lN3vBX7H2uyNL/+VyyK/Ze+w74DEkl07O4Yi8AYNJwxd405ZtuKfSl5Ptu8Vj6+V+Nfe4plqUVs6UVs6VvLhh8nDfL0q5F0q5Ff94WjXarublZixcvnvT3TAEA7sY/AAkAAIxEiQEAAEaixAAAACNRYgAAgJEoMQAAwEiUGAAAYCRKDAAAMBIlBgAAGIkSAwAAjESJAQAARqLEAAAAI1FiAACAkSgxAADASJQYAABgJEoMAAAwEiUGAAAYiRIDAACMRIkBAABGosQAAAAjUWIAAICRKDEAAMBIlBgAAGAkSgwAADASJQYAABiJEgMAAIxEiQEAAEaixAAAACNRYgAAgJEoMQAAwEiUGAAAYCRKDAAAMBIlBgAAGGlqKiYNBoPasWOHIpGI8vPzVVdXp3nz5vUbs2bNmsSfI5GIPv30U73//vuSpJKSEt1xxx2J/a+++qpmz56diqUCAABDpaTE1NTUqLKyUn6/X6+88orq6+u1b9++fmMCgUDiz/v379fFixf77X/rrbc0dWpKlgcAADKA4y2ho6NDwWBQ5eXlkqQNGzaotLR0QIm5zrZt/fjHP9b+/fudXkpi/mg06uicsVis362bkN192d2aWyL7jbdu4dbcUnplt21blmUNO87xEhMOh1VQUJB48NzcXHk8HnV1dSV9S+hXv/qVpk2bprvuuqvf9oqKCvX19enBBx/U5s2bx7yeeDyu5ubmMd9/KK2trSmZ1wRkdx+35pbI7kZuzS2lT3av1zvsGMdLjG3bSbcP1qjefvttPfTQQ/22nTp1Sj6fT52dnXr88ceVl5entWvXjmk9Ho9HRUVFY7rvYGKxmFpbW7Vw4UJlZ2c7One6I7v7srs1t0R2N2Z3a24pvbK3tLSMaJzjJaagoEDhcDhxKigSiSgej2vWrFkDxkajUTU1NenYsWP9tvt8PknS3LlztXr1ap05c2bMJcayLOXk5IzpvsPJzs5O2dzpjuzuy+7W3BLZ3Zjdrbml9Mg+kreSpBR8xTovL0+FhYVqamqSJDU0NKisrCzp2MbGRt15552J0iJJly5dUnd3tyTpypUrevfdd1VSUuL0MgEAgOFScp2Y2tpaHThwQH6/XydPntS2bdvU3t7e72vVknTkyJEBZ1jOnz+vhx9+WKtXr9a6detUUlKiioqKVCwTAAAYLCXfYS4uLtbhw4cHbL/xa9WS9Nprrw0Ys2zZMh09ejQVywIAABmEK/YCAAAjUWIAAICRKDEAAMBIlBgAAGAkSgwAADASJQYAABiJEgMAAIxEiQEAAEaixAAAACNRYgAAgJEoMQAAwEiUGAAAYCRKDAAAMBIlBgAAGIkSAwAAjESJAQAARqLEAAAAI1FiAACAkSgxAADASJQYAABgJEoMAAAwEiUGAAAYiRIDAACMRIkBAABGosQAAAAjUWIAAICRKDEAAMBIlBgAAGAkSgwAADASJQYAABiJEgMAAIxEiQEAAEaixAAAACNNTcWkwWBQO3bsUCQSUX5+vurq6jRv3rx+Y77xjW8oHA4rJydHkvSd73xHpaWlkqTTp0+rtrZWPT09uv3227Vv3z7NmDEjFUsFAACGSkmJqampUWVlpfx+v1555RXV19dr3759A8bt3r1bX/ziF/tt6+vr086dO/X9739fS5cu1TPPPKODBw+qqqoqFUsdG9tWVjQqRSLS9OlSNCrZ9vjntSxpxoxrt4AJbFu6fPnan3ntTo7rx8CJ/wbdKBq99t85p+dNlXR/LU70+oZ7XWTI7xvHS0xHR4eCwaDKy8slSRs2bFBpaWnSEpPM2bNnNXPmTC1dulSSVFFRoa1bt465xNi2rWg0Oqb7DjKhPA88oGXvv3/tx9xcWZGIY9P3fuEL6v7JT9L2hRWLxfrduolbsw+a27Y17ctf1pT33pOU/q/dsUj7Y37TMXBSjqRlkuL33qvou++m93F18LWYkmM+0X9XRvi6uHkd6fR6t21b1gieH8dLTDgcVkFBQeLBc3Nz5fF41NXVpdmzZ/cb++yzzyorK0t33323tm/frtzcXIVCIS1YsCAxZv78+QqFQmNeTzweV3Nz85jvP4Btq6S7W54//djX26spzs2uWDSq3zU3p/d/MCS1trZO9hImjVuzD8ht2yqJxZT7px9Nee2ORdoe85uOQSp0d3en/3FNwWvR0WM+0X9XRvi6GGwd6fJ693q9w45xvMTYg5y6urlRPf/88/L5fOrp6dGzzz6rPXv2aM+ePUnvP5I2NhiPx6OioqIx3z+Z2MmTOtfcrL/8y79U9ty5jr6dlDVjhhan8X8sYrGYWltbtXDhQmVnZ0/2ciaUW7MPmfvf/k3RP50iT/fX7lgYccyvHwOH3/aJxWL6n48+0l8uXqzFf/rsYlpz6LWYsmM+0X9XhntdJPl9k06v95aWlhGNc7zEFBQUKBwOJ04FRSIRxeNxzZo1q984n88n6VrT2rhxo7797W9Lunbmpa2tLTGura0tMXYsLMtKfHjYSX05Ocr+zGeuzZ2byv8PSk/Z2dkpeV5N4Nbsg+Z2wYfu0/6Yp+IYRKPq6+xUdk5Oeme/kYPPQ0qO+UT/XRnj46XD632kJy8c/4p1Xl6eCgsL1dTUJElqaGhQWVlZvzFXr15VZ2dn4ud33nlHJSUlkqQlS5bo4sWLOnv2rCTp0KFD8vv9Ti8TAAAYLiXfTqqtrVV1dXXiq9V1dXVqb29XZWWlAoGAenp69Nhjjykej8u2bRUWFuqpp56SJGVlZWnv3r2qrq5WPB5XcXGxtm7dmoplAgAAg6WkxBQXF+vw4cMDtgcCAUlSTk5O0v3XLV++XMeOHUvF0gAAQIbgir0AAMBIlBgAAGAkSgwAADASJQYAABiJEgMAAIxEiQEAAEaixAAAACNRYgAAgJEoMQAAwEiUGAAAYCRKDAAAMBIlBgAAGIkSAwAAjESJAQAARqLEAAAAI1FiAACAkSgxAADASJQYAABgJEoMAAAwEiUGAAAYiRIDAACMRIkBAABGosQAAAAjUWIAAICRKDEAAMBIlBgAAGAkSgwAADASJQYAABiJEgMAAIxEiQEAAEaixAAAACNRYgAAgJEoMQAAwEhTUzFpMBjUjh07FIlElJ+fr7q6Os2bNy+xv6+vT1VVVTp37py8Xq8KCwv19NNPa9asWZKkkpIS3XHHHYnxr776qmbPnp2KpQIAAEOl5ExMTU2NKisrdeLECa1YsUL19fUDxqxbt07Hjx/X0aNHddttt+mFF17ot/+tt95SIBBQIBCgwAAAgAEcPxPT0dGhYDCo8vJySdKGDRtUWlqqffv2JcZkZWVp5cqViZ+XLl2qw4cPO70USZJt24pGo47OGYvF+t26Cdndl92tuSWy33jrFm7NLaVXdtu2ZVnWsOMcLzHhcFgFBQWJB8/NzZXH41FXV1fSMyq2bevNN99UWVlZv+0VFRXq6+vTgw8+qM2bN495PfF4XM3NzWO+/1BaW1tTMq8JyO4+bs0tkd2N3JpbSp/sXq932DGOlxjbtpNuH6xRPffcc8rJydHXv/71xLZTp07J5/Ops7NTjz/+uPLy8rR27doxrcfj8aioqGhM9x1MLBZTa2urFi5cqOzsbEfnTndkd192t+aWyO7G7G7NLaVX9paWlhGNc7zEFBQUKBwOJ04FRSIRxePxxId2b/TSSy/pww8/1Msvv9yv5Ph8PknS3LlztXr1ap05c2bMJcayLOXk5IzpvsPJzs5O2dzpjuzuy+7W3BLZ3Zjdrbml9Mg+kreSpBR8sDcvL0+FhYVqamqSJDU0NAx4q0iSfvCDH6ixsVEvvviipk2blth+6dIldXd3S5KuXLmid999VyUlJU4vEwAAGC4lX7Gura1VdXV14qvVdXV1am9vV2VlpQKBgCKRiJ555hndeuut2rhxoySpqKhI9fX1On/+vJ566ilZlqWrV6/q/vvvV0VFRSqWCQAADJaSElNcXJz020aBQEDStQ/7/va3v01632XLluno0aOpWBYAAMggXLEXAAAYiRIDAACMRIkBAABGosQAAAAjUWIAAICRKDEAAMBIlBgAAGAkSgwAADASJQYAABiJEgMAAIxEiQEAAEaixAAAACNRYgAAgJEoMQAAwEiUGAAAYCRKDAAAMBIlBgAAGIkSAwAAjESJAQAARqLEAAAAI1FiAACAkSgxAADASJQYAABgJEoMAAAwEiUGAAAYiRIDAACMRIkBAABGosQAAAAjUWIAAICRKDEAAMBIlBgAAGCkqZO9ANMs+6mt/5RX0l3Se5JkT+6CJtw0jSd73wOWw+sBALgVZ2JGIeuntv5TkjRF1546Nz59WRpP9qyfuq30AQBSJSW/hYPBoNavXy+/369NmzbpwoULA8ZcuHBBmzZtkt/v1/r16xUMBhP7Tp8+rVWrVqm8vFxbtmzR5cuXU7HMUeGXr3N4LgEATkhJiampqVFlZaVOnDihFStWqL6+fsCY+vp6rVixQidOnFBlZaVqamokSX19fdq5c6f27NmjxsZG5efn6+DBg6lY5ogt45eu4ygyAIDxcvwzMR0dHQoGgyovL5ckbdiwQaWlpdq3b1+/cY2NjXryySclSeXl5aqtrVVnZ6c++eQTzZw5U0uXLpUkVVRUaOvWraqqqhrTemzbVjQaHUci/ekzMFPGNQdu1qtotGeyFzEqsVis361buDW3RPYbb93Crbml9Mpu27Ysa/jPUDpeYsLhsAoKChIPnpubK4/Ho66uLs2ePVuS1NXVJa/Xq9zcXEmSZVny+XwKhUIKhUJasGBBYr758+crFAqNeT3xeFzNzc3jSCRJd43z/hjIcuC4TI7W1tbJXsKkcGtuiexu5NbcUvpk93q9w45xvMTYdvK3CW5sVEONSbZvJG1sMB6PR0VFRWO+vyTpPd76cJ6txYsXT/YiRiUWi6m1tVULFy5Udnb2ZC9nwrg1t0R2N2Z3a24pvbK3tLSMaJzjJaagoEDhcDhxKigSiSgej2vWrFmJMXPmzFFPT48ikYhyc3Nl27ba29vl8/nU29urtra2xNi2tjb5fL4xr8eyLOXk5Iwnku7U9W8lwTlTxn1cJkt2draxax8Pt+aWyO7G7G7NLaVH9pGevHD8g715eXkqLCxUU1OTJKmhoUFlZWUDxpWVlamhoUGS1NTUpMLCQs2dO1dLlizRxYsXdfbsWUnSoUOH5Pf7nV7mqJzh2iaO43oxAIDxSsm3k2pra3XgwAH5/X6dPHlS27ZtU3t7u9asWZMYs23bNp08eVJ+v18HDhzQ7t27ry0oK0t79+5VdXW1ysvLFQqF9Oijj6ZimaPCL13n8FwCAJyQkiv2FhcX6/DhwwO2BwKBxJ/z8/P1+uuvJ73/8uXLdezYsVQsbVz6HrD+dMXeXknXfxG77YJ3fTf8efTZKTAAAKfwzw6M0pkHLEWjPWpubtbixYsn/X3DiRaNdrs2OwAgvbjtNAIAAMgQlBgAAGAkSgwAADASJQYAABiJEgMAAIxEiQEAAEaixAAAACNRYgAAgJEoMQAAwEiUGAAAYCRKDAAAMBIlBgAAGIkSAwAAjESJAQAARqLEAAAAI1FiAACAkSgxAADASJQYAABgJEoMAAAwEiUGAAAYiRIDAACMRIkBAABGosQAAAAjUWIAAICRKDEAAMBIlBgAAGAkSgwAADASJQYAABiJEgMAAIxEiQEAAEaixAAAACNRYgAAgJGmOjlZMBjUjh07FIlElJ+fr7q6Os2bN6/fmL6+PlVVVencuXPyer0qLCzU008/rVmzZkmSSkpKdMcddyTGv/rqq5o9e7aTywQAABnA0TMxNTU1qqys1IkTJ7RixQrV19cnHbdu3TodP35cR48e1W233aYXXnih3/633npLgUBAgUCAAgMAAJJy7ExMR0eHgsGgysvLJUkbNmxQaWmp9u3b129cVlaWVq5cmfh56dKlOnz4sFPLGMC2bUWjUUfnjMVi/W7dhOzuy+7W3BLZb7x1C7fmltIru23bsixr2HGOlZhwOKyCgoLEg+bm5srj8airq2vQsym2bevNN99UWVlZv+0VFRXq6+vTgw8+qM2bN49rXfF4XM3NzeOaYzCtra0pmdcEZHcft+aWyO5Gbs0tpU92r9c77JhRlZhHHnlE7e3tA7YvWrRIVVVVSe8zVJN67rnnlJOTo69//euJbadOnZLP51NnZ6cef/xx5eXlae3ataNZZj8ej0dFRUVjvn8ysVhMra2tWrhwobKzsx2dO92R3X3Z3ZpbIrsbs7s1t5Re2VtaWkY0blQl5o033hh0X0dHh8LhcOIUUCQSUTweT3xg92YvvfSSPvzwQ7388sv9io7P55MkzZ07V6tXr9aZM2fGVWIsy1JOTs6Y7z+U7OzslM2d7sjuvuxuzS2R3Y3Z3ZpbSo/sI3krSXLwg715eXkqLCxUU1OTJKmhoWHA20TX/eAHP1BjY6NefPFFTZs2LbH90qVL6u7uliRduXJF7777rkpKSpxaIgAAyCCOfsW6trZW1dXVia9W19XVSZLa29tVWVmpQCCgSCSiZ555Rrfeeqs2btwoSSoqKlJ9fb3Onz+vp556SpZl6erVq7r//vtVUVHh5BIBAECGcLTEFBcXJ/2mUX5+vgKBgKRrH/j97W9/m/T+y5Yt09GjR51cEgAAyFBcsRcAABiJEgMAAIxEiQEAAEaixAAAACNRYgAAgJEoMQAAwEiUGAAAYCRKDAAAMBIlBgAAGIkSAwAAjESJAQAARqLEAAAAI1FiAACAkSgxAADASJQYAABgJEoMAAAwEiUGAAAYiRIDAACMRIkBAABGosQAAAAjUWIAAICRKDEAAMBIlBgAAGAkSgwAADASJQYAABiJEgMAAIxEiQEAAEaixAAAACNRYgAAgJEoMQAAwEiUGAAAYCRKDAAAMBIlBgAAGGmqk5MFg0Ht2LFDkUhE+fn5qqur07x58waM+8Y3vqFwOKycnBxJ0ne+8x2VlpZKkk6fPq3a2lr19PTo9ttv1759+zRjxgwnlwkAADKAo2diampqVFlZqRMnTmjFihWqr68fdOzu3bsVCAQUCAQSBaavr087d+7Unj171NjYqPz8fB08eNDJJQIAgAzh2JmYjo4OBYNBlZeXS5I2bNig0tJS7du3b8RznD17VjNnztTSpUslSRUVFdq6dauqqqrGvC7bthWNRsd8/2RisVi/Wzchu/uyuzW3RPYbb93Crbml9Mpu27Ysyxp2nGMlJhwOq6CgIPGgubm58ng86urq0uzZsweMf/bZZ5WVlaW7775b27dvV25urkKhkBYsWJAYM3/+fIVCoXGtKx6Pq7m5eVxzDKa1tTUl85qA7O7j1twS2d3Irbml9Mnu9XqHHTOqEvPII4+ovb19wPZFixYNerYkWZN6/vnn5fP51NPTo2effVZ79uzRnj17ZNv2iO4/Gh6PR0VFReOa42axWEytra1auHChsrOzHZ073ZHdfdndmlsiuxuzuzW3lF7ZW1paRjRuVCXmjTfeGHRfR0eHwuFw4hRQJBJRPB7XrFmzBoz1+XySrrWsjRs36tvf/raka2de2traEuPa2toSY8fKsqzEB4idlp2dnbK50x3Z3Zfdrbklsrsxu1tzS+mRfaQnMBz7YG9eXp4KCwvV1NQkSWpoaFBZWdmAcVevXlVnZ2fi53feeUclJSWSpCVLlujixYs6e/asJOnQoUPy+/1OLREAAGQQR79iXVtbq+rq6sRXq+vq6iRJ7e3tqqysVCAQUE9Pjx577DHF43HZtq3CwkI99dRTkqSsrCzt3btX1dXVisfjKi4u1tatW51cIgAAyBCOlpji4mIdPnx4wPb8/HwFAgFJUk5OTtIx1y1fvlzHjh1zclkAACADccVeAABgJEoMAAAwEiUGAAAYiRIDAACMRIkBAABGosQAAAAjUWIAAICRKDEAAMBIlBgAAGAkSgwAADASJQYAABiJEgMAAIxEiQEAAEaixAAAACNRYgAAgJEoMQAAwEiUGAAAYCRKDAAAMBIlBgAAGIkSAwAAjESJAQAARqLEAAAAI1FiAACAkSgxAADASJQYAABgJEoMAAAwEiUGAAAYiRIDAACMRIkBAABGosQAAAAjUWIAAICRKDEAAMBIlBgAAGCkqU5OFgwGtWPHDkUiEeXn56uurk7z5s0bMG7NmjWJP0ciEX366ad6//33JUklJSW64447EvtfffVVzZ4928llAgCADOBoiampqVFlZaX8fr9eeeUV1dfXa9++fQPGBQKBxJ/379+vixcv9tv/1ltvaepUR5cGAAAyjGNNoaOjQ8FgUOXl5ZKkDRs2qLS0NGmJuc62bf34xz/W/v37nVpG0seIRqOOzhmLxfrdugnZ3Zfdrbklst946xZuzS2lV3bbtmVZ1rDjHCsx4XBYBQUFiQfNzc2Vx+NRV1fXoG8H/epXv9K0adN011139dteUVGhvr4+Pfjgg9q8efO41hWPx9Xc3DyuOQbT2tqaknlNQHb3cWtuiexu5NbcUvpk93q9w44ZVYl55JFH1N7ePmD7okWLVFVVlfQ+QzWpt99+Ww899FC/badOnZLP51NnZ6cef/xx5eXlae3ataNZZj8ej0dFRUVjvn8ysVhMra2tWrhwobKzsx2dO92R3X3Z3ZpbIrsbs7s1t5Re2VtaWkY0blQl5o033hh0X0dHh8LhcOIUUCQSUTwe16xZs5KOj0ajampq0rFjx/pt9/l8kqS5c+dq9erVOnPmzLhKjGVZysnJGfP9h5KdnZ2yudMd2d2X3a25JbK7Mbtbc0vpkX0kbyVJDn7FOi8vT4WFhWpqapIkNTQ0qKysbNDxjY2NuvPOOxOlRZIuXbqk7u5uSdKVK1f07rvvqqSkxKklAgCADOLodWJqa2t14MAB+f1+nTx5Utu2bZMktbe39/tatSQdOXJkwBmW8+fP6+GHH9bq1au1bt06lZSUqKKiwsklAgCADOHo95iLi4t1+PDhAdvz8/P7fa1akl577bUB45YtW6ajR486uSQAAJChuGIvAAAwEiUGAAAYiRIDAACMRIkBAABGosQAAAAjUWIAAICRKDEAAMBIlBgAAGAkSgwAADASJQYAABiJEgMAAIxEiQEAAEaixAAAACNRYgAAgJEoMQAAwEiUGAAAYCRKDAAAMBIlBgAAGIkSAwAAjESJAQAARqLEAAAAI1FiAACAkSgxAADASJQYAABgJEoMAAAwEiUGAAAYiRIDAACMRIkBAABGosQAAAAjUWIAAICRKDEAAMBIUyd7AZnmUtzWqt9Iv++WPjtN+tel0i0ea7KXNeEe+KmtU0m278yV9ix33/MBAHAeJcZBxb+0Fbzy558/7pZm/0JaNN3WuS+45xd31k/tQfftjUh7f2qr7wH3PB8AgNRw9O2kXbt2qbS0VCUlJbp69eqg4y5cuKBNmzbJ7/dr/fr1CgaDiX2nT5/WqlWrVF5eri1btujy5ctOLjFlbi4wNwpeubbfDYYqMGMZBwDAYBwtMWvXrtWRI0eGHVdfX68VK1boxIkTqqysVE1NjSSpr69PO3fu1J49e9TY2Kj8/HwdPHjQySWmxKX44AXmuuCVa+My2QOjLCa73s/s5wMAkFqOvp107733jmhcY2OjnnzySUlSeXm5amtr1dnZqU8++UQzZ87U0qVLJUkVFRXaunWrqqqqxrwm27YVjUbHfP9kYrFYv9u/O+uVNGXY+/3dmV41LelxdC0T7ebsNzqlkT0P1+2N9Op7UXOej6GyZzK35pbIfuOtW7g1t5Re2W3blmUN/7GDCf9MTFdXl7xer3JzcyVJlmXJ5/MpFAopFAppwYIFibHz589XKBQa1+PF43E1NzePa47BtLa2SpLOX/7fGskv7/OXr6ZsLRPtevb+7hrlLJaRz0fy7JnPrbklsruRW3NL6ZPd6/UOO2ZUJeaRRx5Re3v7gO2LFi3Syy+/PKI5bDv5WwiWZSXdN5ImNhSPx6OioqJxzXGzWCym1tZWLVy4UNnZ2frc2am6MIKP7nxuxlQtXrzY0bVMtJuz9/PeaN8eso16PobMnsHcmlsiuxuzuzW3lF7ZW1paRjRuVCXmjTfeGNNibjRnzhz19PQoEokoNzdXtm2rvb1dPp9Pvb29amtrS4xta2uTz+cb1+NZlqWcnJzxLjup7Oxs5eTk6J1ltmb/Yvjx7yybohxPatYy0a5nv9H9Sv616sHszJ2SsmOTSsmyu4Fbc0tkd2N2t+aW0iP7SE9gTMrF7srKytTQ0CBJampqUmFhoebOnaslS5bo4sWLOnv2rCTp0KFD8vv9k7HEUbnFY2nR9KHHLJqe+deL+ekovzbN9WIAAOPhaInZvn277rvvPknSypUr9cQTT0iS2tvbtWbNmsS4bdu26eTJk/L7/Tpw4IB27959bTFZWdq7d6+qq6tVXl6uUCikRx991Mklpsy5LwxeZBZNl2uuEzPS679wnRgAwHg5+sHe559/Pun2/Px8BQKBfj+//vrrSccuX75cx44dc3JZE+bcFyyu2KtrBYUr9gIAUo0r9jrsFo+ln//VZK9i8o32rSUAAEaLfwASAAAYiRIDAACMRIkBAABGosQAAAAjUWIAAICRKDEAAMBIlBgAAGAkSgwAADASJQYAABjJsm3bnuxFpMoHH3wg27bl9Xodnde2bcXjcXk8nhH/S5uZguzuy+7W3BLZ3Zjdrbml9Mre09Mjy7J09913Dzkuo//ZgVQdBMuyHC9GpiC7+7K7NbdEdjdmd2tuKb2yW5Y1ot/hGX0mBgAAZC4+EwMAAIxEiQEAAEaixAAAACNRYgAAgJEoMQAAwEiUGAAAYCRKDAAAMBIlBgAAGIkSAwAAjESJAQAARqLEAAAAI1FiAACAkSgxYxAMBrV+/Xr5/X5t2rRJFy5cmOwljdrKlSv193//91qzZo3WrFmj3/3ud5Kkn/zkJ/L7/SorK9OTTz6p3t7exH1eeOEFfeUrX1FZWZl++MMfJrZfvnxZW7ZsUXl5uVatWqV///d/T+xLh+dq165dKi0tVUlJia5evZrYPpFZh3qsVEmW++OPP9aSJUsSx/1rX/tav/tkQm5J6urq0ubNm/XVr35V//AP/6Dvfve76unpGXZNpucfLLdbjvs//uM/avXq1VqzZo0effRRhUKhYdeTydldcdxtjNrGjRvt48eP27Zt2wcPHrR37NgxySsavQceeMBubW3tt+2Pf/yj/bd/+7f2Rx99ZPf19dnf+ta37IaGBtu2bfuXv/yl/dBDD9nd3d32xYsX7QceeMD+/e9/b9u2bb/wwgv2008/bdu2bf/mN7+xv/zlL9u9vb22bafHc/Xee+/Zf/jDH+zbb7/djsfjtm1PbNahHmuic3/00Ud2aWlp0vGZktu2bburq8v+9a9/bdu2bff29tr/9E//ZL/88ssZf9wHy+2W4/7pp58m/vzaa6/ZTzzxRMYf86Gyu+G4cyZmlDo6OhQMBlVeXi5J2rBhgxobGyd5Vc742c9+prvvvlu33nqrLMvShg0bdPz4cUnS8ePHtW7dOnm9Xt1yyy3y+/06ceJEYl9FRYUk6fOf/7xmzpyps2fPps1zde+99yovL6/ftonMOtRjTXTuoWRKbkmaNWuWli9fLknKysrSkiVL1NbWlvHHfbDcQ8mE3Nf9xV/8ReLPkUhk2PVkevahZEp2SswohcNhFRQUyLIsSVJubq48Ho+6uromeWWjV1VVpdWrV6u+vl7xeFzhcFjz589P7C8oKFA4HJakIfeFQqF+++bPn69QKJTWz9VEZh1qvsnQ1dWldevW6eGHH9bbb7+d2J6pubu7u3XkyBGtWLHCVcf9xtySe477tm3b9KUvfUnHjh1TdXW1q475zdmlzD/uU1P+CBnGtu2k268fVFP88Ic/lM/nUyQS0fbt2/XSSy9p+vTpg45PlnuozJZlpfVzNdjaBts3nqxDPdZEmzdvnk6dOqU5c+bo448/1je/+U0tWLBAy5cvz8jcfX19qq6u1t/8zd/ovvvu07lz5wYdm0n5b87d09PjmuNeX18v27b1L//yL3rxxRd12223DTo207Pv2rUr4487Z2JG6Xq7vH7AIpGI4vG4Zs2aNbkLGyWfzyfpWpPesGGDzpw5o4KCgn6nnkOhUGJcQUFB4kNy1/fl5+cn3dfW1iafz5fWz9VEZh3qsSaa1+vVnDlzJEm33nqrvvKVr+jMmTOSMjP37t27NXXqVO3atSuRww3H/ebcbjvulmWpoqJCgUDANcf8uhuzu+G4U2JGKS8vT4WFhWpqapIkNTQ0qKysbJJXNTrRaDTxnunVq1fV2NiokpIS3Xffffrggw/0ySefyLZt/ehHP5Lf75ck+f1+HTlyRD09Pfr000914sSJfvvefPNNSdKHH36oS5cuacmSJWn9XE1k1qEea6J1dnYmvql06dIl/eIXv1BJSYmkzMv93HPPqb29XXv37k38H6Ybjnuy3G447pcvX+739sXx48dVXFzsimM+WHY3HHfLnuzzXwY6d+6cqqurdfnyZc2bN091dXWJBmuCjz76SFu2bFFfX596e3t155136nvf+55mzJih48ePa//+/ert7dVf//VfJ/6PTpL279+vY8eOSZK++c1vauPGjZKutfEdO3aopaVFXq9XtbW1uueeeySlx3O1fft2vffee2pvb1d+fr7uueceff/735/QrEM91kTm/upXv6p//ud/VlZWlnp7e7V27Vo99thjiftkQu7ra1q1apU+97nPyev1SpK++MUvqrq6OqOP+2C5ly1blvHHvaOjQ9/61rfU3d0t6drZhO9+97v67Gc/m9HHfKjsv/vd7zL+uFNiAACAkXg7CQAAGIkSAwAAjESJAQAARqLEAAAAI1FiAACAkSgxAADASJQYAABgJEoMAAAwEiUGAAAYiRIDAACM9P8Bg9ADXqgIx7QAAAAASUVORK5CYII=",
      "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": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "_, losses = predict(model, whole_dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "anomaly_flag_prediction = [ l > THRESHOLD for l in losses ]\n",
    "x_segments = []\n",
    "count = 0\n",
    "for i in anomaly_flag_prediction:\n",
    "    count = count + 1\n",
    "    x_segments.append([count*60, count*60 + 60])\n",
    "y_segments = [ [0,0] for i in x_segments]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "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"
  },
  "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
}