Health_Index_Prediction_Models.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyMcgX8wE+hMvT40QoeWVzkI",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Ogunfool/Prognostics-Strategies-An-Aero-engine-Use-case/blob/main/Health_Index_Prediction_Models.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "In the \"A_Residual_Similarity_Based_Method_for_Remaining_Useful_Life_Prediction_Using_Degradation_Degree\" notebook, we showed that a more sophisticated model can be used to improve the accuracy of the RUL estimator model. So in this notebook, different deep learning models are used for the HI prediction with the aim of achieving better results."
      ],
      "metadata": {
        "id": "HIpSYAKHW5o9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import scipy\n",
        "import math\n",
        "from sklearn.cluster import KMeans\n",
        "from sklearn.model_selection import train_test_split \n",
        "from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score"
      ],
      "metadata": {
        "id": "L51gDtlPowvB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vmW7SgcfzLO8"
      },
      "outputs": [],
      "source": [
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "from keras.models import Model, Sequential\n",
        "from keras import losses, optimizers, layers, activations, regularizers\n",
        "from keras.layers import Dense, Conv1D, LSTM, GRU, Input, Concatenate, MaxPool1D, Flatten, GlobalMaxPool1D\n",
        "from keras.losses import SparseCategoricalCrossentropy, categorical_crossentropy, mean_squared_error"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from tensorflow.keras.optimizers import Adam, RMSprop, Adagrad, SGD\n",
        "from keras.metrics import Accuracy, Recall, MeanSquaredError, MeanAbsolutePercentageError\n",
        "from keras.callbacks import ModelCheckpoint, EarlyStopping"
      ],
      "metadata": {
        "id": "tZfcDDB12DDs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qjThQcYqA6zN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2efd8562-2d98-46b7-fa17-352bd807ec4d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[?25l     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/172.2 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m172.2/172.2 kB\u001b[0m \u001b[31m5.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h"
          ]
        }
      ],
      "source": [
        "!pip install -q -U keras-tuner\n",
        "import keras_tuner as kt"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install git+https://github.com/tensorflow/docs"
      ],
      "metadata": {
        "id": "kMRjc0UJo_iI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow_docs as tfdocs\n",
        "import tensorflow_docs.modeling\n",
        "import tensorflow_docs.plots"
      ],
      "metadata": {
        "id": "OshwNxI8pGLE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Next, we'll confirm that we can connect to the GPU with tensorflow:\n",
        "device_name = tf.test.gpu_device_name()\n",
        "if device_name != '/device:GPU:0':\n",
        "  raise SystemError('GPU device not found')\n",
        "print('Found GPU at: {}'.format(device_name))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2GTXIN1z12VY",
        "outputId": "f70947fd-27b9-46e4-cbac-46fe485b7484"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found GPU at: /device:GPU:0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Helper Functions\n"
      ],
      "metadata": {
        "id": "NvaPKlxHmUA0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "np.set_printoptions(suppress=True, linewidth=100, precision=2)"
      ],
      "metadata": {
        "id": "MnQh6z29olxC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Checkpoints - List and npy files\n",
        "# np.save() - Saves a single array in a binary numpy format\n",
        "def checkpoints(filename, checkpoint_data):\n",
        "  np.save(filename, checkpoint_data)\n",
        "  checkpoint_variable = np.load(filename + '.npy') #Load so that we always have an on-hand version of the checkpoint\n",
        "  return(checkpoint_variable)\n",
        "\n",
        "# List Checkpoint\n",
        "def list_checkpoints(filename, checkpoint_data):\n",
        "  np.save(filename, checkpoint_data, allow_pickle=True)\n",
        "  checkpoint_variable = np.load(filename + '.npy', allow_pickle=True) #Load so that we always have an on-hand version of the checkpoint\n",
        "  return(checkpoint_variable)"
      ],
      "metadata": {
        "id": "n7i_27BpmXIF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Load Data"
      ],
      "metadata": {
        "id": "SSTXqbBZ8KZr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Load normalized_train_data_list and normalized_unwrap_train_data\n",
        "from google.colab import files\n",
        "uploaded = files.upload()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 107
        },
        "id": "SyEdrqlI90r0",
        "outputId": "17c5e887-64e5-4425-92ac-4b357873bfd8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-48452f3d-1bd7-4453-9624-ff2f05444a70\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-48452f3d-1bd7-4453-9624-ff2f05444a70\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving HIval-dfr to HIval-dfr\n",
            "Saving HItrain-dfr to HItrain-dfr\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "new_model = tf.keras.models.load_model('/content/best_model_CNN.h5')"
      ],
      "metadata": {
        "id": "7iwGFU_gQRon"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x_train = np.load('/content/x-train.npy')\n",
        "y_train = np.load('/content/y-train.npy')\n",
        "x_val = np.load('/content/x-val.npy')\n",
        "y_val = np.load('/content/y-val.npy')"
      ],
      "metadata": {
        "id": "2H9qv7wv8Ji6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Data Preparation."
      ],
      "metadata": {
        "id": "IfMBgMnKXk8H"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Use a moving window to convert 2d data to 3D to capture the local relationship or auto-correlation in timeseries data."
      ],
      "metadata": {
        "id": "A2TEC_AHX0vm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "T = 5\n",
        "new_len = x_train.shape[0] - (T-1)\n",
        "fake_col = np.zeros((new_len,T))  # Not the same lenght as the actual data\n",
        "# make single output supervised dataset\n",
        "for d in range(x_train.shape[1]):\n",
        "  X = []\n",
        "  series = x_train[:,d]\n",
        "  for t in range(len(series) - T + 1):\n",
        "    x = series[t:t+T]\n",
        "    X.append(x)\n",
        "\n",
        "  X = np.array(X).reshape(-1, T)\n",
        "\n",
        "  # Concatenate Features (TD)\n",
        "  new_data = np.concatenate((fake_col, X), axis=1)\n",
        "  fake_col = new_data\n",
        "\n",
        "X.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lfoKgt6k_N9T",
        "outputId": "8b025340-b515-4ac4-ea5b-e06f614fe0f2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(41452, 5)"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "NT_X_train = new_data[:,T:]\n",
        "NT_Y_train = y_train[-new_len:]\n",
        "print(NT_X_train.shape, NT_Y_train.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LA1lXC7qLEoC",
        "outputId": "a308f105-c5dc-45f2-96dc-9ff4e252558b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(41452, 40) (41452,)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "NT_X_val = new_data[:,T:]\n",
        "NT_Y_val = y_val[-new_len:]\n",
        "print(NT_X_val.shape, NT_Y_val.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sTAtl0ikKM4T",
        "outputId": "013c8237-1078-4e23-8ac3-dce9df8261c5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(12299, 40) (12299,)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Checkpoints\n",
        "# Save new x-train, y-train, x-val, y-val\n",
        "checkpoint_NT_X_train = checkpoints('NT-X-train', NT_X_train)\n",
        "checkpoint_NT_Y_train = checkpoints('NT-Y-train', NT_Y_train)\n",
        "checkpoint_NT_X_val = checkpoints('NT-X-val', NT_X_val)\n",
        "checkpoint_NT_Y_val = checkpoints('NT-Y-val', NT_Y_val)"
      ],
      "metadata": {
        "id": "4FIH9MtmLYtw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Prepare data as NxTxD"
      ],
      "metadata": {
        "id": "nrSHSBntLSb9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "array_list = []\n",
        "for dt in NT_X_val:  # Loop through datapoints\n",
        "  data_list = []\n",
        "  for i in range(8):   # Loop through feature size\n",
        "    data = dt[(i*T):(i*T+T)]\n",
        "    data_list.append(data)\n",
        "  one_dpoint = np.array(list(zip(data_list)))\n",
        "  array_list.append(one_dpoint.reshape(-1,T).T)\n",
        "\n",
        "len(array_list)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9E74UY2_KtC6",
        "outputId": "262494b4-f224-405e-c784-ae49ad1d124f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "12299"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "NTD_X_train = np.array(array_list)"
      ],
      "metadata": {
        "id": "AY1ABGK9RrgM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "NTD_X_val = np.array(array_list)"
      ],
      "metadata": {
        "id": "swIv5juSVe5J"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "NTD_X_train_list = array_list"
      ],
      "metadata": {
        "id": "kUcVRdhgeJb3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "NTD_X_val_list = array_list"
      ],
      "metadata": {
        "id": "pE-o3auaeSey"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Checkpoints\n",
        "checkpoint_NTD_X_train = checkpoints('NTD-X-train', NTD_X_train)\n",
        "checkpoint_NTD_X_val = checkpoints('NTD-X-val', NTD_X_val)"
      ],
      "metadata": {
        "id": "EHrNu_uISM3n"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Use lists checkpoint instead\n",
        "checkpoint_NTD_X_train_list = list_checkpoints('NTD-X-train-list', NTD_X_train_list)\n",
        "checkpoint_NTD_X_val_list = list_checkpoints('NTD-X-val-list', NTD_X_val_list)"
      ],
      "metadata": {
        "id": "Oqia9peJd67R"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(NT_X_train.shape, NT_Y_train.shape, NT_X_val.shape, NT_Y_val.shape, NTD_X_train.shape, NTD_X_val.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7FaXVADvcN6m",
        "outputId": "075e0de5-4758-45c8-b8f8-e5ab223eca09"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(41452, 40) (41452,) (12299, 40) (12299,) (41452, 5, 8) (12299, 5, 8)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Save files as csv\n",
        "np.savetxt('NT-X-train.csv', NT_X_train, fmt='%.18e', delimiter=',')\n",
        "np.savetxt('NT-X-val.csv', NT_X_val, fmt='%.18e', delimiter=',')\n",
        "np.savetxt('NT-Y-train.csv', NT_Y_train, fmt='%.18e', delimiter=',')\n",
        "np.savetxt('NT-Y-val.csv', NT_Y_val, fmt='%.18e', delimiter=',')"
      ],
      "metadata": {
        "id": "kuHl9YJMawQM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Model Building Helper Functions."
      ],
      "metadata": {
        "id": "FO3hG2cXgXGX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Let's create some helper functions for the training process (We are trying to select a model so, many models will be trained and they have similar execution configurations)\n",
        "# Learning Rate Scheduler:\n",
        "def lr_scheduler(STEPS_PER_EPOCH):\n",
        "  lr_schedule = tf.keras.optimizers.schedules.InverseTimeDecay(\n",
        "    0.001,\n",
        "    decay_steps=STEPS_PER_EPOCH*1000,\n",
        "    decay_rate=1,\n",
        "    staircase=False)\n",
        "  return lr_schedule\n",
        "\n",
        "def get_optimizer(scheduler=None):\n",
        "  if scheduler is None:\n",
        "    return tf.keras.optimizers.Adam(learning_rate=0.001)\n",
        "  return tf.keras.optimizers.Adam(lr_scheduler())\n",
        "\n",
        "# Compile and fit\n",
        "def compile(model, optimizer=None, scheduler=None,  loss=None, max_epochs=1000, STEPS_PER_EPOCH=1000):\n",
        "  if optimizer is None:    # that is, i want to set Adam optimizer & learning rate to 0.001 by default or use a lr_scheduler function\n",
        "    optimizer = get_optimizer()\n",
        "  else:\n",
        "    optimizer = optimizer\n",
        "\n",
        "  if loss is None:\n",
        "    loss = 'mse'\n",
        "  else:\n",
        "    loss = loss\n",
        "\n",
        "  model.compile(optimizer=optimizer, loss=loss)\n",
        "\n",
        "  return model\n"
      ],
      "metadata": {
        "id": "Ua9TtOxUkKS5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Plots Helper Functions"
      ],
      "metadata": {
        "id": "dJc5tkZYvX_d"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Helper function that plots, saves and shows plots\n",
        "def plot_loss_accuracy(filename):\n",
        "  loss = history.history['loss']\n",
        "  val_loss = history.history['val_loss']\n",
        "\n",
        "  epochs = range(len(loss))\n",
        "\n",
        "  plt.plot(epochs, loss, 'r', label='Training loss')\n",
        "  plt.plot(epochs, val_loss, 'b', label='Validation loss')\n",
        "  plt.title('Training and validation accuracy')\n",
        "  plt.legend(loc=0)\n",
        "  plt.figure()\n",
        "\n",
        "  plt.savefig(filename + '.png')\n",
        "  plt.show()"
      ],
      "metadata": {
        "id": "8NAScmNHg70e"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Finding the baseline model."
      ],
      "metadata": {
        "id": "82oBs8kAP-3N"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "A baseline model is a good starting point. Based on the data shapes, different models were tried and are still been tried to achieve very high results. The models used can be grouped based on the data shape.\n",
        "\n",
        "1. Model 1: A classic feedforward network with NxD data.\n",
        "2. NxTD data: Feedforward NN, Multi-tail ANN, CNN and LSTM.\n",
        "1. NxTxD (3D) data: CNN, LSTM.\n",
        "1. Window sizes [3,5,10] were tried. window size 5 had gave best results.\n",
        "2. Note: These models were implemented quickly (i.e. so much attention wasn't paid to tuning the hyperparameters at first) because the aim is to find a good enoug model that will ten be throughly tuned. Different data shapes were also tried to do a quick exhaustive search and analysis to make informed decisions. \n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "pjpH4u_NZRzL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "T = 5\n",
        "D = 8\n",
        "K = 1"
      ],
      "metadata": {
        "id": "Gn7xodKdiWup"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Fully Connected ANN Model with NxD dataset."
      ],
      "metadata": {
        "id": "0_n8ZGpYfefD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tf.keras.backend.clear_session()"
      ],
      "metadata": {
        "id": "5QbesSu1VFIV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Fully Connected NN\n",
        "FC_ANN = tf.keras.models.Sequential([\n",
        "    tf.keras.layers.Dense(32, activation='relu', input_shape=(D,)),\n",
        "    tf.keras.layers.Dense(16, activation='relu'),\n",
        "    tf.keras.layers.Dense(K)\n",
        "])"
      ],
      "metadata": {
        "id": "RLKRE1H4l82s"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "FC_ANN.summary()"
      ],
      "metadata": {
        "id": "bBCw-FkE78_o",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0c90b0fe-48f9-4f85-83c9-a95672549f35"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "dense (Dense)                (None, 32)                288       \n",
            "_________________________________________________________________\n",
            "dense_1 (Dense)              (None, 16)                528       \n",
            "_________________________________________________________________\n",
            "dense_2 (Dense)              (None, 1)                 17        \n",
            "=================================================================\n",
            "Total params: 833\n",
            "Trainable params: 833\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tf.keras.backend.clear_session()\n",
        "\n",
        "model = FC_ANN\n",
        "model = compile(model)\n",
        "check_point = ModelCheckpoint(\n",
        "    'best_model_FC_ANN_NR.h5', monitor='val_loss', save_best_only=True)\n",
        "early_stopping = EarlyStopping(monitor='val_loss', patience=200)\n",
        "\n",
        "history = model.fit(x_train, y_train, epochs=1000, \n",
        "                    validation_data=(x_val, y_val),\n",
        "                    callbacks=[check_point, early_stopping],\n",
        "                    verbose=2)\n",
        "\n",
        "# Load best model\n",
        "best_model = tf.keras.models.load_model('best_model_FC_ANN.h5')\n",
        "\n",
        "# Make predictions with best model \n",
        "y_pred = best_model.predict(x_val)\n",
        "\n",
        "# Evaluate with best model\n",
        "val_loss = best_model.evaluate(x_val, y_val)"
      ],
      "metadata": {
        "id": "DOFOKocRxBbV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "best_model.evaluate(x_val, y_val)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aSYj-lQgCPEz",
        "outputId": "a84b8dea-62e1-40e5-d55e-ab1b5e51afea"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "385/385 [==============================] - 1s 2ms/step - loss: 0.0231\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.023127106949687004"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plot_loss_accuracy(filename='ANN for health index prediction')"
      ],
      "metadata": {
        "id": "26tOUO684XvH",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 469
        },
        "outputId": "bc11d4bd-8a03-4b90-e701-11eb663b8f80"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 0 Axes>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot(y_pred.flatten()[:1000]);"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 430
        },
        "id": "Ictp2y-q9wGI",
        "outputId": "fbc42cbb-9b72-4a45-da30-c46ebbca76c7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGdCAYAAADAAnMpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAACE6klEQVR4nO2dd5wU5f3HP7t7nWvAcXeUg0NAehMEAbun2GsiIkEkaqKCQYlGsWE0ivqLqElUIko0sUBMLIkiCidYwgHSQbqA1Ds44ArXd3d+fxy7+8zs9LIzs/t9v1682Jud8uwzM8/zfb7Vw3EcB4IgCIIgCJvw2t0AgiAIgiASGxJGCIIgCIKwFRJGCIIgCIKwFRJGCIIgCIKwFRJGCIIgCIKwFRJGCIIgCIKwFRJGCIIgCIKwFRJGCIIgCIKwlSS7G6CGYDCIQ4cOISsrCx6Px+7mEARBEAShAo7jUFtbi06dOsHrldZ/uEIYOXToEIqKiuxuBkEQBEEQOti/fz+6dOki+b0rhJGsrCwArT8mOzvb5tYQBEEQBKGGmpoaFBUVhedxKVwhjIRMM9nZ2SSMEARBEITLUHKxIAdWgiAIgiBshYQRgiAIgiBshYQRgiAIgiBshYQRgiAIgiBshYQRgiAIgiBshYQRgiAIgiBshYQRgiAIgiBshYQRgiAIgiBshYQRgiAIgiBshYQRgiAIgiBshYQRgiAIgiBshYQRgiAIgiBsxRWF8qzize/2YP/xeowf0RW9C+UrChIEQRAEYQ0JrRn5dOMhvLV8L346Vsfb3tgSQOXJJptaRRAEQRCJRUILI75TJY2DHMfbfvZzSzH8D0twpKZR9DiO41Db2GJ5+wiCIAgiEUhoYcQbFkb420NakZV7joseN+W9tRj4xJfYXl5rafsIgiAIIhFIbGHk1K8PCKWRUyR5PaLbF24qBwC8tXyvFc0iCIIgiIQioYURnzdiplm37wTu/Mca7D9eH/U9QRAEQRDWkdDRNCEzTSDI4bpXlwMADlU3hL9P8skLIx6SVQiCIAjCMAmtGRHzGdlZcTLqeylIFiEIgiBiSWNLAKv2HJd0L3ArCS2MhM00zE1lb3DSKaeSippG3PbW9/h6x9HYNpAgCIIgGH71jzW48a9l+MtXu+xuiqkktDASNtMwob3+YJD5vvX/Rz/ejNJtRzBp3qqYto8gCIIgWL45tSj+x4q99jbEZBJcGGn9n80zwmq+QkLKwRMNEIN8RgiCIAg9LNpcjqXbj+g+3hNnE1BCO7CKmWlYQiYbKduch7xGCIIgCI0cO9mEO99ZAwD48ZnLdUVuxtvsk9iaEW8kmkaMkMYkwKlzFKpuaMGcr3/EwSpxTQpBEARBnKhvDn8WZgBXi1KAhdtIaGHEF/YZEf8+cMp9xB8Iiu8g4NGPN+PZz7fhptfLzGgeQRAEEYf4JYImtBBnskhiCyMhzRgnIZmGHhK/yoeldGsFAGD/cdKMEARBEOL4mRWwTsUIaUbiCdVmGimfEcGz0CKiQZHyRyEIgiASE3ZOUesGEO8ktDDiEwntZVF2YOXTIrD3PPLRJpw1qxRVjH2QIAiCSGxYbbten5E4U4wktjASzsAqoxlpaA6IajzU8O7KfThS24QF3+/X3UaCIAgivmAFEE7f9BJ3wkhCh/Z6vdHp4FmO1DSh7+OLjF8n3p4agiAIQjesz4heM028pZZIaM2I79SvlzLD/HfjoahtnzLbtlfUqroOySIEQRBECDbTt/7QXrNa4wwSWxgJF8oTfxgamgNR26a+ty78ecXu49ihQiAhzQhBEAQRgjX96w1yiLcMrAktjIRuppRmpKElWhgR8t3OSsV94k2CJQiCIPTT7Gc1I/rOEW/TSkL7jPgUfEYOSNSkYWnyK3sfeUkaIQiCIAA8/slm/L3sp/DfukN742xaSWjNSEQY0R/n3ahCe6JVnVbT2ILdR0/qbRJBEAThUFhBBNBvpok3839CCyOhe9mkQqCQotEvfiyb1VWrYmT0rK9w4Qtfq/JHIQiCINyBWLZv3XlGjDbGYSS0MBJyYG1s0RnoDaDp1LFC6ZZNaqMlBGvXkVqcbPIDAL7ZcVR3uwiCIAhnERrbWXT7jMSZNJLYwsgplUWThHZDDSGfkWZBYjTWW1qLZqRk9je620IQBEE4l6r6lqhtegvlkZkmjgjdzJrGaGlVLSETj9CRta4pIuAoPTT7jtVj7b4TuttAEARBOJ/qhmhhRKpQa6JBwgiAippG3ef4cN1BNLYEeKFagEAdpyDAnvt/S3H9q8tx4ES97nYQBEEQzkZUM6I76RlpRuKGUAbWHw7VGDrP38v2RplpNh+sjvwh86zVN0eEloMqQokJgiAId1LTGC2MBKk2DYAEF0bMyv9xqKoxSjOyas/x8Gc5yZcVQNKSfbzv4i3DHkEQRCIj5h9CVXtbSWhhxGfS3QwEuShh5FhdE+97KfYzphmhdoVsiQRBEPGDmOChP7Q3vqSRhBZGzLK5+UWEkcPVET8UuYetsrY5/LlFRTZXgiAIwp2ITQXvrtiHSfNWoU4k7FeOeEvsrUsYeeWVV1BcXIy0tDSMHDkSq1atkt3/pZdeQu/evZGeno6ioiLcd999aGzU7zRqFmaZaYJBDs0Bfnjwun1V4c9ymhFWG9IUIGGEIAgi3qhr8qOuyQ9OxIFwwer9+HrHUbxdtlfy+ECQw9HaJv7GOLPTaBZGFixYgOnTp2PmzJlYu3YtBg8ejLFjx+LIkSOi+7/33nt46KGHMHPmTGzduhVvvvkmFixYgIcffthw443iM+le+oOcbI0aWWGEOU6oXSEIgiDcjT8QxKDff4n+M7+QHePrm6TzXU14YwXOfHoJNh6oCm+LL1FEhzAye/Zs3HHHHZg8eTL69euHOXPmICMjA/PmzRPdf/ny5RgzZgxuvvlmFBcX45JLLsH48eMVtSmxwCzNyO7Kk5j33V7J7//w2VYs3HRY9Ds2OVqLQDNCDqwEQRDu5mSTP7wgffDfmyT3k5uPVuxuDYh4f9X+8LZ4mx40CSPNzc1Ys2YNSkpKIifwelFSUoKysjLRY0aPHo01a9aEhY/du3dj4cKFuPzyyyWv09TUhJqaGt4/KzDLZ2Tdvios2Vohu8/d767FhX9chqr6Zt52VlJe8xMlPiMIgogn1CZYTVKxOGbLjiR0npHKykoEAgEUFBTwthcUFKC8vFz0mJtvvhlPPvkkzj77bCQnJ6NHjx44//zzZc00s2bNQk5OTvhfUVGRlmaqxhdjD6DdlXX4w2dbedtYbcjf/rc3pu0h4oOyH4/ho3UH7G4GQRAiqDW/q5mP2DQR8SWKxCCaZtmyZXjmmWfw6quvYu3atfjwww/x2Wef4amnnpI8ZsaMGaiurg7/279/v+S+RjArtFcLPx49yfubnFYJo4yfuwL3LdiAbeXWaBAJgtCP0PwuhVbNSJwpRpCkZee8vDz4fD5UVPBNEhUVFSgsLBQ95rHHHsPEiRNx++23AwAGDhyIuro6/OpXv8IjjzwCrzdaHkpNTUVqaqqWpunCjpsZuqQ/EESSzysrNVOeEUILB443oE9htt3NIAiCQZg/SgrNmpE4k0Y0aUZSUlIwbNgwlJaWhrcFg0GUlpZi1KhRosfU19dHCRw+X2umUbsn20YLolfUPFALNx1Gv5lf4LONh1VLzQShhF9vLXINUMQXQWjDTDMN+4qbIYqs2nPcMRpVzWaa6dOnY+7cuXj77bexdetW3HXXXairq8PkyZMBALfccgtmzJgR3v+qq67Ca6+9hvnz52PPnj1YvHgxHnvsMVx11VVhocQuquqalXfSSG56suI+d7+7Fs3+IO5dsE72QY03yZewFr2lyNWyp7IOfR77HI98JB0RQBAEH6vMNEYdWA9VNeDGv5bh0pe+NXQes9BkpgGAcePG4ejRo3j88cdRXl6OIUOGYNGiRWGn1n379vE0IY8++ig8Hg8effRRHDx4EB06dMBVV12Fp59+2rxfoZMTIhUUQ8y8qh9+/98tms/56/NOwzMLt6naNy8zFS0BMsUQ5qC3+qda5iz7EUEOeHflPjx93UBLr0UQbmf5rkp0yk1XLYz4RFwWhARM9BnZe6zO2AlMRrMwAgBTp07F1KlTRb9btmwZ/wJJSZg5cyZmzpyp51K2ISxap4Z3bhuJk03SAo6Q4vZtSO1NmEZAb/lPlSQnkaaOINTww6Fq3PzGSgDAe3eMVHWMT4Wdgu8zoqtpYZzmkpjQtWnuPP80ye9SJJ6Mv9w8FF3apot+l57iQ5KCdMtqQvKyUmWdm+z2qSHchdVatmQ1oyVBEPjhYMQPo6nFPM0IL5rGoNeI3gJ9VpHQo0t+Vhq6tssQ/S5JIld8erIPT1zVX/wYr0fyuBBsMaS0JPloGqc9LISzsdpnREpAJwiCDzsPTH7re1XHqHm9SrdFyq4Y1YzEwN9dEwk/utx3cS8AwA1ndOFtl1oFej0eXNQ3H4vuPQev3HwG77skn0dx9VjXHBFGvB6PrD3RaQ8L4WysFkZIM0IQ8jQ0t9aXSdLxrmhdewoDHHYfPYn5q/bBr9JHxWmLXV0+I/HEdUO7YFjXdujcNh3/XhvJYinp2expfQj6FGajooZfRTHJ61X0iK5jiiEFOE5WM2L15EK4H9aUR8IIQdjHD4eqcfVf/oeeHTLxq3OlXQCk0Pr6CmeaC1/4GkBrXpNbRhUrHu80NwAaXQB0bZ8RFeMtNfBmpkbkN2EGV5/XoygRn2TMNMEgJ+szEiRhhFCAfUSszjNCDqwEIc3cb3YjEOSwvaIWT/z3B83HB4Mcbn97NR7/ZLOq/aXMNKv2HFd5PbUtiw0kjEggloDm5pFdMbxbW8l9kn0eTfVulDQjjf4A1u07QRoSQhJW1Wq18JqswsGOIBKVvMxI1vDaRr/MnuJsPlSNJVsr8Peyn1TtLzXTqFV4sGOHE7QkNLpIIHREvaRfAZ65biDPTicUPHxej6ab+sn6Q6hukA4FfmXpj7ju1eX4U+lO1eckEgt2QGmxOrSXeSdIa0cQfDpkGSthwkbDheaR3UdPYk+leD4QqaRnahev7G4OkEVIGGFhhQs19nG1ph05Dlc3Ku7z129+1Hxep7DrSC0WbT5sdzPiFnYQeX7RdkuvlZwUeb7V1tsgiETBTDOpP8ihvtmPC1/4Ghf8cZnoPlJmGvWOqZzIJ/sgYYSBXfkJpU6xGy90VvV5PZbcVKPx5HZSMvsb3PnOWiz/sdLupsQlwnFHqGnzB4KY/eV2lP14zPC1WGG7iZL1EQSPppaA8k4ysNOJP8Bhb2W97P5S5ULUykTseoLMNA4jO025rgxLlGbE63WEusuJbDnkjGJM8YbSKujj9Yfwp692YfzcFYavxQrflDmYIPgYFdBZ2aIlGER5TYP8/hLb1WpGeD4jqo6wFhJGGPp0jJRfV5NQJspnxOdB78Iss5sFzhGPCuFEhAMPx3G8VU55tfyApgX2UmSmIQg+jQY1I6wG3B/gFE34Uj4jaoURdi8n5BwhYYThxuGtic/apPiipE4xU4lQGEnyepCZmoR1j10c3nZaXhvMvnGw6W11G1SB2BqEKtl9x+tx1qxSvLpsFxZ8vw9Lth4RP1AH7KVIM0IQfOQ0I7eOLlY8nhUI/IEgyhWEEY8H2HesPirJmWoH1iDrMKvqEEtJ+KRnLFcO6oQkrwe9C7Nlo1xCiAkjANC2TUp429m98tA2IwWJDoki1iC09T77+TZU1DSJOrMGgpym0HO5a5EwQhB85IQRpWSYAF+I8AeVNSNLtlbg883lOPf0Dvj7L0eEt+sx0zgB0owIuHRAR3TPaxO1XWxhL5b0TEiQ4wybWRpbgpj45kos3OTeqBRSjFiDcBEkV16ATbinB9KMEIQ0cmYaNYsANhrHH+AUNSOhUOBvdhzlbVcb4c/KIk4QTEgYkSBfEDMuKox4hRE30TuZZVr/dmcl7n53rTknswEp+yZhDKFmRE5FW9uorO2Tv1jkY3NA3j5+oq4ZLy/Zif3H5SMCCCJekNOMqBJGmMmiJRjEIZ3+XgE9Dqz2yyIkjEjRKTcdc34xDJ1z0wEAd57XI2ofNQ8YJYdqhWQRaxA+XgGZx62mwZhmhG/Tln+u7/9gA15csgPXv7Zc17Wa/AHc/vb3eHv5Xl3HE0SsafKbqxk5Iqh9phaO43C0tgn/WPGT7ALEadE05DMiw6UDCjG2fwHqmgO8mjQh1DgKOUH95QRIFrEGoWZELl+AUc0Ie2al1dfyU3lNjtbqG1A/XHsQS7YewZKtRzBJhfMfQdhNU4u0ZkSNZpidT5r9Qd1m1UCQwy/f+h6bDlZj1Z7j+PP4oaL7BclM4y48Ho+oIAKou4FqVWZxD6lGLEEoD8s9kw0qQw+b/UFsPlgdpdVjT60kiBu93fXNxsIkCSLWGDXTsO9UVUOz7nYEOWDTwWoAwH83HJLcj32fnTBNkTBigK7tMlCQLV+PQMxMc3bPPMPXrmlswZP/3YIN+6sMnysWkChiDULhQ855Tcm0EuK+Betx5Z+/w5vf7eFtZx2xrS7e6KMHhnAZcs7jaoLY2Hdqztf6S4CozabKGzscIIyQmcYAHo8HKx8uwfJdlSjISRPdJyUpOivrbWd3x3e79KdH33XkJEpmfw0AmPe/Pdj77BW6zxUrSDFiDVHCiMxA5Fdws1++qxLbymvx2amoracXbsUd554W/j6W3vc+HXWeCMJOjL4SrM/I/3bpL9+gVhvPCi1kpokTRvfMQ48OmbxtT1zVDz3zMzH94t4Y2CWH953XQK4HAGFBxOmwD7ub6+s4GeEYIqexYKuCbj5YjX+u3s+7Rze/sRJPfrqFd8wXP5RHrsVsV6tl0YuavAyEfj5ZfxAX/nEZdlbU2t2UuMGoSd4sbaPa0N6gsxQjJIxYxa1jumPJ9PNQmJOG/Kw03Dyya/g7YX4Slkv6FcSieTGBfblobrEG4fgnt8Jh1chX/vk7/O5fG7Fse2uOAqmB8J0VP4leTGklZfR2y70jhHGmzV+P3ZV1uHfBerubEjcY1S7ImXmUqDwZcRTXVZuGNCOJwwOX9EZhdhpuHV0Mr0yvp6f4sOz+82PWLithVwo0t1hDdG0a6X39AQ6lWytw/av/C2+b/Nb32HywGsdOKke9sKdev78a97y/zrI8IkYyxRLqUevUTChjdD43ohkZ/ocl4c9BjtOc8dUJGShIGIkRbdukoGzGhXji6v6KYV7FeW3wxFX9orYLE7E5HVZdSGYaaxAKI3Kq4pZgELe9vRpr91Xxto/7axkqJHIasOcPChzs/rvhEKa+Z00iviTyYCVchpwwoUZQ8ZtlpuGA9GQfb9uR2saohQM/z4j90ggJIzEklKE1qtqviBSbkuSL2uY2eBMjzS2WEJX0TGZAk/LzqGsO4KbXy8TPzwiUYkfvrqwTPc5oYUT2nbA6cocgzMComaa+2VhSwnA7ghzSUvjzx4inS3HO80txoi4SMux3mNMICSM2INSM9O2YFf4cej6SRVaGbhuU2faSLGIN0UnPpPeVs0nXSeT1UEoZnSIR9cLe76+2VWD30ZOi+729fC/+XLozajurZjZiSyeIWCGXbdvjaU0FIceOCvF3RHM7OA4ZjDDCtmv9gSrR7U6YWUgYsQGhJuTFG4eEP4eqBackRd8as9R4sYJ92I2ulAlxtCQ9a9ERAcOh1TnuSE2j6ICVrCIE95dvrcaFL0RHgAWCHGb+5we8sHgHDlbx63CwArvSc79kSwWe/myL64R1Ir5Qevw+unt0TNoR4Dh0ZFJNsO/WIeYzK+M7IbSX8ozYABspsGT6ueiZH9GMHKlprdQotuJ022DLc2C1sR3xjNDWK/eMhARdLfgDwbBz3ANje0d9LyY0A1B1w9kqpy2C7JWsz0hAQYi6/e+rAQB9CrNxw7AuyhcmCAtQCu1tnxkbnz8PPLxFQigbKyAURiLvnANkEdKM2AGrJEgShNaEanmIa0bcpa52mhowHhE+EnLyqp6sjmx9jON10SmqxcyJamFTvstVwG5R+dyX18iXXCdEoBfTNJwQHgu0zi/souTgiYgAwhbLDHDOGp9JGLEBduAVDsIdTkXMiKm/5RJNfbB6P8a/vgJV9fprGphNwGFx7PGIUL1qtBieELbehtgzqcZMIwWrGYlSEzN/Wp1gjSDMwEmaa/Z9YqsJs9t5ZhoHtJ2EERtgBZCQOvo/U8fgwj75ePmm1gqLUj4jUtlXH/jXRpTtPoYXF++woMX6YF9OkkWsQdivcsW69NCokIdCykyjRl/CakaEfiGs+UltLgxySyLsJPQI54mYY2I9/rHKxEammjAr2DvBT4SFhBEbYJ3zQoLJoC65mHfrmehd2Oo/IrXi3HVE3uP6iM6S7VYQlHGQOlHXjL+X7eWFmhHasXpAYQUGsWtJRdOogRUyhNoP9lIX/HGZqueEctkQdhJ6P/46cZit7fCAr5VmNSPNAXHB5OjJJhypbUSzyYsZLZAwYgOsZUYq7XWqlGOgAkor2VjCvhBCLeDU99fi8U9+wJ3vrOFtDwY5zF68A19tq4hFE12P1cII+zyJqaGNmGnYvApCfyjhz/rvRulS6AThBEKmjrzMlKjvpLR2pxdkiu5vFPZdZbWlrLDBjh3Xv7ocI54uxeZDEWfXWEPCiA2w46zQgTWE3kHebDW9XvYdq8ecZRGHSeGkGapKuXLPcd72zzeX40+lO/HLt1Zb38g4wGpFa4uCWjdkpjlc3YAth2rwzY6jqvOCsILO3kp+dkjhldToPDweoK7JnMRRBKGV0PyvlGGbZdb1AzHxrGIL2sIII4yZJjQ/7K2sw1vL90Ydp6XtZkOhvTbAjuk+iWgEvemwnaIZGfvSNzw1vFoH1n0W1TqJVzbur4rZtcRuYbLPC47jMGrWV+Ft95b0UpVXhjUBTXlvLeqaBuHGM4tOXUtwMRXne+Pb3Xj28214+aYhuGZIZ8X9CWdEUcQLIU2wlqrsHo/HEl8nVhhpZMw0IZPNr/+xJuoYwN6CpqQZsYXIgyJV0Ehv1VLWWclOhE6HHID9x+vxjxU/8WyYQvzMqnqvRKpxIsIT/90Ss2uJmWm8HuCYwJ/jpSU7VUX1NAiyvs5mnK/1aEYqT7a24z6qREvYQEiAFhu787PSorYBrZoIK6JwWOUkqxkJmWmkFn12akZIGLEBnmZEShjRKaI2ykz0dhIMcrj4xa/x2Meb8Zevdknu18K8mOf/cRl2VtTGonmECsTMNIEgx0ukFNlX+XxCLV5dsz9czEt4KTsHSYJQQ0ioEA7dE8/qhuvPENfUeT3SIcG/OKurrnYEOX6orpgDq1RhPBJGEgz2MZDSgLCqvtvO7q46uVSTQzQjQoJcRGvz7c5Kyf38An+Dr3cctbRdhHrEhBG/hDCiBmFG2NpGP855fim2lddAqBvRMkayRy7dfgRlPx7T1T6C0ELYZ4QZu4vapeOpawcgScIH0OvxSCb1u1anqTHIcbzggUYRzYgUEi6MMYGEERvo0SET/TpmY0zP9pL2xU45aTjrtHY49/QOePSKvqo1JU7xGRHCK0Uv4z8izDehVoW5eEsFbpxTFlUmmzAPsTEzEORQXq0v8+n+4+JCzBebKwznZfjhUDX6Pb4Ik//2PcbPXeGIpE5E/MI+X16PB+NHtGo1fntxdAkFIVLlDvTW8+LkNCOnhBGpMHhyYE0wfF4PPr3nbNnVnsfjwft3nBX+3Bp1o6z1cEo0jRB2ctl4QDp8TCi5y9V7qKhpxIP/3ohbRnXDHafqk8z4cBPeuX2kscYSoixYvT9qmz8Y5OUu0IKU3ZoDF2Xm0TpETpu/nucgS6IIYSXsAsvrAZ65bgCmXdQLhTniviKRfT2SY5xeuUCoGeGF9iq8q3Y6sJIwYhNqPK49IsnRlHCDZkQOYb6JYJDDkdpGtElJQptU/uP62MebsWz7USzbHjHliNVPIawjEIwWHNSy/4S4MBLkom3aWgdmoVDb6lxIfidCqEyDObDvgNfrgcfjURREWveV1v7q1VK0vpOsmSZaMyLZHvIZIZSQiroRolRu3S7UNkuYibOipgkjni7FWc+URu17WKd5gDCP6oaWKD8ftUgKzhwXZabRq7IOn9LQ0c6nsSWAf5TtJTOlTfA1I+qfVa/HIzlm633iWx1YI39LJT2Tao9dkGbEJeiNrnEKUt7bQloEwsj3e1uTotWKJLNyquCVSOyoOIk/fqmuHtLxumYs+H4/rj+jMwqy02QFVD2hvXLEiwLgn6v3o2u7DJx1Wvvwtg/XHsD0f24AAKQlb8W2py6zq3kJCyuMaEnL4PVIF6nTKxhwHCeZgbWmsQXT5q+TrPdEmhFCESNpt52A2skgykwjcyA5JbqLKe+uxXOLtuGWN1cBkL63HMw3HzitKJge1u+vwu/+tRE3vb6Ctz0kiADOyTOUaLCTv7b5XEYzYpLPCKuBbAlw+GS9dGkFOyPo3T3DJRB6M7I6BTnB4Z+MY6TQTMO+5ELbqlBwIaTJSrVfCVq2uzXEdvup3DFStnIxwcGomSYeIBOMc2EfZS1abLk8I1KPfLs28rVsAkFOEE2jfpzUkj3WbEgYcQlu14zIKTFe+HJ7+LOwrgl7XFSkDWlGVONEYVZKWcFxYknPrLkWIc87K35CyeyvcVBnLplEQRjaK8Wie89Bt/YZvH2lfUaiz7P0/vPxxNX9ZdvCcXyBXkslXr2Zv83A3TNcAqHWgdWpqFWTRwsj4vHyAPmMaEEq6ZKdSAmTHIxH0wj3V+uzRPB59OPN2HXkJJ5ZuNXupjgaYWivFH0Ks3HneT2YfT0ISGh4xRKQ5WelKgrmQYHPiBYotJdQJFQd1a2o9QEQChgtjFQvVDeKvXCkzRfHzhWPFFICalAsmsagCytpRsRR2y16I6YShZCPhsejbFJkQ349nmjTdPg7kWfe41F+F4Ic4NH5vNtpDnX3DJdAuF8zIv0d+3IJNSP1MjHyiW6m0eLk6UT/Grnmi33359KdWLjpsL5r6TqKCOH2aD6rCT2vaoT+Tjnp4c8ej7RQLtblHihX+XWrZoSEEZcg5zNy97vR5aArTzZFVUW1Ezk1OftyCVcJbBZNoZkmHiIkjKBlwNFq0rrnwp5am6MZyey6XLTw8P3e43hh8Q7c/e5aXdei5F7G8NlZtMQFhMYiNaGxHXMjmpEmf1BTNE2rZkS5LXKZq+WwU+ikJ8wlyAkjCzeV8/4+WtuE4X9YgpHPLLG6WapROxdWnmzi/c1qQ4Rhi4nuMyIccM7v3UFyXylVsBTpKT5dbdKCXGiv8Dvhc6GVeHtSYi1cOdD/2VGEFgZqrBzZacnIOPV+dcpJR5sUKW8J8ZMpa0b0Px9kpiEUUVu1FwBWn0oUVtMYnSjMLtRoMWoaW7D3mHT4otBnpEZQ9TXREFpe+nfKltxXq5kmLclaYYQT8QsJEQyKqEZkzqNqP+dZqQzx8EebNEVJGEVNyOdPx+pwy7xVCVklOWymUalZWPPoxdjw+CVIT/HhkSv6YnCXnKh9RM00HkBJN0JmGsJSnBgNoQW5OSP0/J9QqCvDmml+OlanuyZKvCDUjMip0rUOTslJXkv9lJSyrwrNelL7q/1Zbo2mCQY5VIsI3e+v2o+/l+1VPL4lEDSlXpWaZ+Ge99fhmx1HMX7uCsV9443Q+6U2g2l6ig85GckAgE656fhk6tlR+4hpKdT4jLSG9qpqRhSUgZVQJEWDMOLAwAlV2VKVJsyVu4/j5Km08PO/j64gm2gI+0tuwhCm2Vci2euxNLeNnKZMLM+IlAZE7DwcF712dKvLyN3vrsXg33+JLYdqor47cEI598d5zy/FgJlfSAokavtFzYpfTXvilYjPiHnnFDuXV4XPiBHIZ4RQxIlJq7Sw4UCV4j5KwsjLpTtxzV++AwB0yEwV3ceJgphVCPtLOJAMKcrVfW6f16PJNKgVuXvNiegxpDUj0n4ncn+7hUU/tPqDvbV8T9R3ajJrHqpuhD/IYWfFSUPtCD1bPxyqxlOfbkF1fbS2JpHDf8PCiImTuXhor8dSvw47x0/KM+IS3J6B9fu9JyS/C2k71Dik/ni0DgDQIUtcGEkklISR64Z2xvr9VbrOneTzWJrbRimsV/i9pNBhsm+JUxGb56V8RjiOg8fj4f1mo5NM0ikT4BV/al0MHK9rxovjhvD2SWSzaei3m5nPRzSaBtZqRshMQyiibZUa2dcNxeRqGv1Yt++EJr8GPav2dftOYMepuij/XnMALy5WV23WqQgnaKGZZkDniENrWjL/VU9lBI1rhnSKOneS12ubmQaI9vGQzNYqcZooM43ahjkUsf5qltBEhExybJcZnWOEk5SY2SiR8/5EomksFkY81movSBghFEnSGefvlvDXF5fs1DSYaf1ZlSebcN2ry3HJi98AAH77wQa8XLoTG1WYj5wKK0zlpCfzNCNXDuqIYd3a4bUJZ2BMz/Z45PK+vGPZQUdsNZck4zNS0jcfr004w1Db5fIgiGVglYy8URtN447XQJJAMNp01SKhGQklDuRVkjW4nlZjJmav53ZNlFZCz6GZ8ruYYNBqpjHvGtHXtO7cite279KEFvSuUt2yWmmRSf4jBvu7lKpYAsDhqkbR7TUNzgl/1grrxPv5tHN4mpFL+hcCAC4b2BHv3n4WCpmsjwB/dSVm55bzGenbMRtjeuUZabpsqC0nEtmr1jdE8pwu140EOC5qgl/0QzneWfFT1L4h803QRDONmhUzK2AOfWox1u2TNs3GG6GfbqZmQepURgVLuetRnhFCES1mCXYQcmIacDGaA0ENq1yOt68agYtVLPErbKpvo5PplJvOEyqE2g45WVZMM5LskzbTeCSOyUpV74L2/BfbJL/jEO00IlfHRhXulkUQDIrnjnj0481R20KaETOFETWhvWz7qupbMPW9dcYu6iK0hvaKIXQ4j7XJxE4TDUDCiGvQohlhBwW3aEaa/UHVWUKv/PN3mDZ/ffhvVriorG0W/c2sCaOFEdDM9H6PJcLU+AB/whD+LOGKh/1LSjMiNTh5PB7REMBQ3gQ1vLtyn+R3YnkSpB5jtcnMXPIaSBKQEEbEaBYx00jdSzmNEXu8npBPt4w9ZhCJptF/jjcmDUdhNlNET2pHi4Ysu4dCEkZcgpbQXjcKIy2BoOq2/iBwnmPVw+U1jRj8+y8x9sVvsHxXZXg7O1GzaeXdWgDsSE10enQ26ZlQ+BBqMtjJSWzVm+QVFzhazy0+uZmVJE0snbWUD4Ja84vbzTRBgTZQjleW7mo9hhHU9NwZtmil8FlQs4hOpNpRWmrTSJGXmYrbzu4e/lvSZKKyW7U6+dtpogF0CiOvvPIKiouLkZaWhpEjR2LVqlWy+1dVVWHKlCno2LEjUlNTcfrpp2PhwoW6GpyoaNGMsF72bhFGmv1B3SYl4W882eTH9opa3PzGyvA2dqJmE0DZrZrUy4n66Gy1cpqRKMHCI/PdqW1yNmupY8wgEAxqyDOi7pxunxeDnHh4rxjvr9qP2sYWnpCu5zH3G9SMuGToMQWzQnvZw/Wcij2mfRt++oPLBxbKHmtmWLIeNAsjCxYswPTp0zFz5kysXbsWgwcPxtixY3HkyBHR/Zubm3HxxRdj7969+Ne//oXt27dj7ty56Ny5s+HGJxJapFw2/4Bbomm0+IwIaVExSrMvGl8Y0XVJ2xHLqMpOGGnJ/NoyQqGL/VtUy+HzSq6mWzUj0dvNCgX2B6Ojadhng9WSSD0zwlWeO94CaQJBbZVYA0H1mhTJcwSMCSOJFFGjpVCeHOxzK3UqOS0f+y4LHfuVFl52j4Wak57Nnj0bd9xxByZPngwAmDNnDj777DPMmzcPDz30UNT+8+bNw/Hjx7F8+XIkJ7falIuLi421OgHRpBnxu08z0hJQ7zMiRM1PZN9DNnMlO8iGkkW5AbFsl+xvyUpLkvwO4PeH2KMlN/lwnLhK1zzNiHwG1tbrAx+tO4AH/7VJoo3qzDxOhn13gxynOWcQu7+en8/zrdJxaxPRTGOm2VeP1tbrAUJLLaUxwIzrmYmmpUxzczPWrFmDkpKSyAm8XpSUlKCsrEz0mP/85z8YNWoUpkyZgoKCAgwYMADPPPMMAgHp4k1NTU2oqanh/Ut0tBTKe2dlJNzPNZoRv3qfET2w46JYnY7NB6tx5tOl+Odqd9S8EbuvfGEkWfAdf18lB1YPILnMk5pkzCrm2KoZkRYmQte/b8EGycRfQtw4L7YIzK1a3g+O4/tShT5V17fgtWU/qjoHuzjQ038uGXpMIdQ/ZobdSrqMyPQru0gQZlBWMsPYvQ7TNHpUVlYiEAigoKCAt72goADl5eWix+zevRv/+te/EAgEsHDhQjz22GN44YUX8Ic//EHyOrNmzUJOTk74X1FRkZZmxiUpGsw0u0+lTAfcoxlp9gc1qaG1wq61WQfWUPfc8/46VJ5swu/+tdGyNpiJqDDikdaMCFc97KAlNkjJDUxSd8k0B1aR3xYUmVjlcIuGSw72Hms1uwjLyIeOnfHRRjy3KBJWLXdKVhjS82a6URtlFDMfOz3PMPsKpgqEEaXIQbud+S2PpgkGg8jPz8frr7+OYcOGYdy4cXjkkUcwZ84cyWNmzJiB6urq8L/9+92xWrUSvRlY3SKMtAS0rfy0IqUZCV1Tjd+JkxAz07C/QUkYGd6tbfizWUKEWYOZmM8I+3P1qP+lDgkEOcmKtnbDZlhduec4vtlZKbM3n4Agi23o87c7+Oc4cKIB3+48KnoOv4gwo4VEkkWs+K16NCPswkJo2lfSjNh9uzT5jOTl5cHn86GiooK3vaKiAoWF4p66HTt2RHJyMny+iENd3759UV5ejubmZqSkRGfPTE1NRWoqFUJj0Vu1101Jz/T6jKiBPTM7+YRWb24bOMUcWOubI78rXeDAKhQUHrqsDwZ2zsFlAwvx6cbD2i4u0VlmVflt9RmRNtPoMxmIH3T5y9/ix6MnsWHmJWijIWlbLGgRvLvf7BAXGsQIBvm+UcGIHSGKiW+uwt5nr4jazgq8ZvZ5PGJW6DjPfCqZG0Yar4yZRkkzUiVSiTmWaFpup6SkYNiwYSgtLQ1vCwaDKC0txahRo0SPGTNmDHbt2oUg82Lt2LEDHTt2FBVECHFS4jwdPKCuJLpe2MmsgRFGXNQ9PMSEzHrmdwlVvMKBLTMtCfdc1As987PEzTQy1m+pLjPLAY4TqU0TNCiMSB2yvaIW/iCHdfuqtJ/UYsQETpbsNGnhKcBxuPLP34b/lpFFdF9fCbe+W0YwtVCerutHPgvnDKcXftfcvOnTp2Pu3Ll4++23sXXrVtx1112oq6sLR9fccsstmDFjRnj/u+66C8ePH8e0adOwY8cOfPbZZ3jmmWcwZcoU835FAqDXOfCVpbtw5z/WuEIoefgj8cgIM2B/vdiK0W32bTEtUrLMyicqmoYZ6sRWTKnJ0s+b1IrXLGEkyEWbzXjRNDpWoW67v4C4KY4lVaD9YgkGOZ5vVFgY0XCP2Pusp/p3QmlGLPipkpoRmYux73KyRgdWu9Gslxw3bhyOHj2Kxx9/HOXl5RgyZAgWLVoUdmrdt28fvIx/Q1FREb744gvcd999GDRoEDp37oxp06bhwQcfNO9XJAB6VeBf/NBqUluytQJj+8snvYln2Pe3iacZOSWMxLpBBhFzYL12aGd8vrkc553eIeo7oSzLyh+soHJOrzwUtctAr/xMzTZrs/zfvt5xFF8LTBK8iZEDahq1qZSV7q8TM7Qq+THJaUuFgkDo92mZj3g+J+oPEz0+UTBzutcjO7ACh/D5cHrpC11G0qlTp2Lq1Kmi3y1btixq26hRo7BixQo9lyJOYTShlFOd9GKHeDRNaMB028AptmpOS/bh7V+OEN1fLukZO4Ddf0lvDBYU7BJitZlG9JrMRYMch0FPfKn7eLegZCYRRkuwCDWhoT+13CG+AEiaETms+KV6ssHLhfbanUdECWd5bBGSmJXdkuALZhHNiLsGzhZmsln4m3MU95fNwMqqdlU8Z1JzjJXhtOzE1qLCtyi6JfL314nzpqJmREYYEWrOQqp9vWYauf45VNWA5T8ekz0+UTA1tFdCdJTrVlb5IdSMmBU1ZxUkjLgEvdE0IeIh74IReKG9/mgHVhe41PAIaUauHNQR/TplK+4f5TPCjFNJPGFE+TmREtyslJfZiU1NIj/hHkrzohNvv5IwIqcZmfjmSt7f+jQjkc9y/XPJi9/gZJNf9vh4xyyfJHaYlpYdZHxGZEJ7nW6moeW2S9AbTRPC2Y+h9fBDe8UcWGPcIIOE1PBqVzvCgciIZkRqLLRSDcwGDzXriLpS9Blx4AOgNJnLaUYqoqo6G3P6lesfMUEkUYlF0jPZPCNeOTONKc2yDBJGXIJxzYhJDXEZ9c2tA6VU0rPJf/seq/YchzPXxtKE/AnURlkJPek9Et+xHviaQ3stHO14ZhoVCeoOVTVIHh/e5vClu5J8lJokHU0jJKwZ0XCLhPWACGks8RnRcwxzkFDL6fRoGhJGXAK7Yu1TmGVjS9zFU59uASCdDh4AJs1b5brBNmSmURtlJUzgy3NgZb6TCw8OIbVKtlIzwjpkqjHTCHPWCJt8qKoBZz69JPK9sebZgpxmREjk9+sM7XXbC2ITRmvTsEfrcWBl30Gh1pTMNIQpJDOzyWu/GKb5eDMLOLmJz05lF5XyGQFaE4i5bahtCZtpdGpGmD/ZZ8OIA6uVYx07Geoy0wja/OLiHThW18zsoLdl1qFkOtJiug2GHVjVX19rPaCExoIOMmqmkcst5ERIGHEJyUnyhc2UcLiGznKk8owArS+9E30G5AhpRtSa7+SiadhJR835pHpK7rnsXWBMm8dqRvTUERI63QqVK26LpgL0aUY0DQMyZppEd4iXwu5uYeWP6CzMMW6MRkgYcQnsCljPA+/w59BSNh+sxuV/iqTGFpppvB73rfyMO7BGPrMTM6sZkZpwJFX2Mk0RFu7Tip8njOhxxhT87YI7rtRCbcKIes3In0p3YuKbK3mmLjFhvfJkk+uEeKuI5fMkdy1ZzYjDJwEK7XUJrG+Anvff6Q+ilfzq76t5fzcJzDQ+j8d1PiOaHVhlomkCzI83ZqaRfsjk7NWdc9ORl5mCkr4FeGHxDtF9eD4jJlRYdsP9VnZg1SCMqNzv6x1HMfvUPSjITpM8fuvhGgz/wxJMPKub6jYkAnYPs1LJDAHna7NIGHEJ7CShrxKvsx9EK+H5BiB6Ze31eFznoBd6BtQ4nALyPiPs6lYotGhB1nwo071fP3A+vB4Plu04IrkPK4w06zHTCK4flS7dXbcfgNZomlOaEZlxYPmuSkyatyr8dwNTBVoq8ugfK35S3YZ4JpbPj9y1WDOrcAHgcFmEhBG3wD5keiZOpz+IViKMrBD6HHg87puMtGpGhH6u7CpJaxFFyWganUbf0G+QmygDRs00Sj4jDrz/Sqp/XT4jMuPAit38LKrkwKoDgwOtUe0FuyAQDg3kwEqYAhtNo8tMY2JbrGT8iK6mnq+mMTohk1AY8Xo9rhtsA0FjDqwsUrKI1jwjcgMpBw4vjRuChy7rI7mP3DjM+ozoqbMULXy47Y5Ho0UYiWhG5PYRPwZwprDmJGKqGZH5jtWGCN95py9ISTPiErxeD64b2hmVJ5vQMz9T8/FOtxeG0GIH14swNNTn8aCFM+6HEEv8Ic2ISrOK3H5ak39JDbxyZhqOa60qDADPfr5NdB+1eUrueX+dqv3415c3yzhyrlVolFoTHXsqJYGRhX0s3GbGtItYjLJygjRfM6ItmmbSKHv9f0gYcREvjhui+1h3iCLqk3gZ4WSTSGiv5Vc1l5CmwKfSNuLxeLD2sYtxxlOLo76Tmmikky5JJT2Tvr6a/rW06q/g72ifEbc9AfxsuUqo+X1C85fTM9Q6Caf0FC+aJirrsvz79bNhRZa0SS1kpkkQYvmy7D9er/vYWFQnrmlo4f3tdaHPSAgt03e7NilYev/5WDHjIt52rXOOVVV7rVTe/al0J+9vN2hGlNqkpQqrks9IQ3MAr3+zm7eNMrBqx24FNCuMaHVgtbvtJIwkCLEcTH4hqBgqRUZKdDSAFju4XoTRGD6vxxV5J1j0trZ7XhsU5qTxtml9NkJ7D+/Wlrdd7H5qwcrBcNn2o7y/42Fy1SK4K9WmWfPTCcljAPcK67Eilpo1tRlYo31G5F8wEkaImBDLl+WnY+o0I51y06O2xUIzIqQ1tDfmlzWEliRWSoztXwgAOC2vjaZrv3P7SIwfEVHtZsokNpN6/m4c3iX82UozjRA33G+lV1ZL8czw8yKhSxNLSsePpnFBh9lI2CfH4HnUvAIX9s1HmxQfzixuG/WdVM0pNW2L5fsnBvmMJAhuGHwBbfU2zMLjgTP19CowY/jomZ+JlQ9fhNyMZMG55WtjpCX70DM/kuY9K1X7cPLcDYOY68UOJYdWJ6AkACRriKVW0oyIaSTZPnHL+JEIZKclY/3MS+APcOj7+CLed0kGomnsFkZIM5IgOFEtLfbox8KBVYiRRF92YfbdLMhO05REK0RDcyR0ekDnHMn91IQDx7KqaHR7nPd+KMHWq1JG/vdV1bdEbaPQXvVEfHJi8wwn+7xRwsXLNw3hvUM+rwe3ji4O/60kbJCZhogJblnZpOiYEI3i9bjPZySEpYOfVDQN01V1TJbOoV3b4s/jh+L5nw2SPUYKMVnEKkHRicK5EEUzjR7NiMT34+euiNrGJprTa+a94++rdeWFSVT0Pu3P/2wQrhnSmR/a6/FgIhOuq6wZ0XlxkyBhJEFwYuhiWnK04KHFDm4WShlYm/1B3P72arzx7W7pnWKNjbeTFdzqmvhJ5a4a3AmDu+TqPHP0vddToVoNbsjAqoQWLaKelTvbJXr7Z/GWCry3cp++g12FclI5oyyZfh7vb1bTEcrPJIymYduj1Da7c1GRMJIgOHEleOmAQow6rT2v2JbWyad9mxTD7fAq5Bn5dOMhLNlagT98ttXwtczGjvGDncjrmqJXvXpXWGLH6U0xr0SUz4g1lzGEcmivuRlYo65vkgNrVX2z8k6ELEleT1SyS7F3X1i1lxVYFKNpjDXRMCSMJAi6autZTIrPi/d/dRYeZFKEa5187r6gp+F2tFbtlR5s65udp2a206zEdpVYv4mNeXqTnlmlGYnKM+JEaUQBTdE0oQ8aupOfgVX9cUICbuxcjaip/WM2YpcShvay7SEHVsIRBDkOS7ZU4O5316BaxFnNDkLPvpwHuBJmmJ88HunJkuM4PPnfLYavYTbhwc/Ca0jXpon01n0Xn44ubdPx6BV9I8eJSiPRPSw0M4gdZtUAGZWB1YG6EaVnW0sYfIs/iFmfb8Xuo3Wqj+H7jKg+TOQ8+o91G7EsRif2nrHvi9fD/1upbXYLIxTamyBwHHD731cDANq3ScVT1w6wuUWRl4kVRrTaLYUVefXg9XgkB9uth2t1layPGXYMIExfFbXLwHcPXsj7Wm2LhJOpqGbEIh8ioTDiRAdvYZPyMlPRt2MWvt1ZCUCbMPLuyp+wdl+Vtuvzomn0d1DAiWpZk7Hj8eH5g5x6d9hHQmttGoqmIXTx/A3REQtysIPv4epGs5uji9Czz1ctajuHsAKvHuQiNhpaoqv+OgE7Nd9KlxYTKMWOEaYzFxsMrco7E22mcaA0IuCeC3uiI5M9V4uZZteRk5qvd4gZJ4z0jpNledMxOKFryUAt7jMSOd7r8fBCfSkdPGEJN56praiRnRU47ys5XXR76D3xaFAlCjFDGJEt8ObwOcqO8UNp4hbrT7FD1GhGzMzIe+BEPTbsrxJtjxMdvIUSgFDtrqU2jV+H6udobVOkKQb6x5F9azJm/cRrhnTG4C45uOv8Hor78sfNVoSaEX40DZlpCAfAOpEFYqyTTksWn1DEbZ7azi2sNKoH+bLqziQWPg6/vaQ3bvxrWdT2tgoRTGoFSqGgIXYbUiWeHT2c/dxSAMDS+88Xqdpr2mWsw+PhPata2uw3+J4YGTL8p8w0FTWNyElPFg3pjxeMTudpyT58MvVs3cfz8oxERdPIH0uaESImsCubWK9U2Bcim6mBIfbwa/UZaTbBZ8SNGVhDWDmAjOjeDpueuIS3raRvPu69SFzTpbVNQjOD2MrMCjPN1sM1UaKcM31GohvFdoeWJrcY9NswaqbZffQkRj5TipLZXxtqh1OxanHQ61Q4b0nfAlX7ewXBAOzQpjS2kmaEiAnBoH2aEfYZZy8t9nL0zFdXrC1ErM00wSAX07TlUsRKnsxK49ereWPSmYrHiIf2ikXTCM000celWlDFubUwotCB1YHSiAh6JwyjP8+QmSbIYcnWCgDAgRMNxhricMyez9+9YyQWbjyM687oorwz+KY7n9fDU9UoJz3T0UATIWEkQWCFgNgLI5GnnL02++wv/M05qKht5BVeU4MZwoiW/ghwHLy2pwdiq4Ta3xYharVb0T4P0cclWaAZ8XjEMrA6TxgRa5IwdNPOtqjFH+RsX3VbjVWPT35WGm4d0131/rzaNB6+mUYph5PdYwmZaRKEYAzNNMJxxwOEHbJmXtVPdL9+nbJxQe98zddqCXCaHPnEkAt5FE5SsRbklHDiGK/fgTV6Hyt+nlckyZ3DbisAZWGkf6ccjOjeDtcM6WR9WwyYIYIcZ3uq8Vhh94TO+oykJns1OrBa1CiVkDCSIHAx1IwIV0FeD/C7sb2x6uGLcNOIruHtZry4zYEgPp4yBpcNKDR8LjGEPaUnKsEKHLiQDyN2X8WFEWWfESvmMK/HJdE0IrAThs/rwT9/PQovjRsS3sb6ZJmJEZeTQJCzfaKzGrufntB7wo5PGSk+3julJFDaLTCSMJIgsIOtCQEoskQp309FAeRnp/G2mzFA9euYjQGdc/DaL4YZP5kKAlZ3nkacOMarva9CE4yoQ7MFv1DcZ8T0yxhGrEliztbsJNIpN92ithhJesa52klcC3YrgJqYCskZKUma2mP3LSJhJEHYeLA6/NnqjIjCF0DqITf64j54aR/cfk7EnnrVYPPV1cIFs98x2SQdOHuGULivt44uBgA8MLY3b7uoX4EVA6SIZsSJPiNiTB7THenJPoxnNIwslgkjhtLBx7+ZxinPT2NLZHzyeT2a+t3ue0QOrAnCZxsPhz9bPZ+2rmZ5YTOi+w0uyjV0HWFioD/dNARlPx5D5ckmiSOMQz4jyoiaaZjPM6/qh99ecnpUpE6sZBFRzYjD7isgPsEV5qRh0xOXSDr25melWtIWo4Xy7F51xwq73sfQO9fo5xf11NIeu8cSEkYSEMvt4wqake8evAAVNY3oU5ht7mU9HmSm+lCpPfO1JEL1NPmMKCPuwMpEUXk8UYJI63H2+Yw4uDujkIsw0pJOXBvGzDTxHk3jFBoEFca19Lvd94iEkQTE6tV9dMAmf0uXthno0jbD0jaYhqCrnKIZiYfQ3ujjRLaRz4gmkpTiN3Vyor4FryzdpevYQJDjRXk4JVePmUSqaNv7u4SFQ7W0xu5bQsJIAhKIcWhvLB9ys+2eUtE0gSCH5xZtw8ju7XCRyuyIlhCDvvWc0iTkZaozAei937HSjHgQrR10is3fKMIIJbNY89MJrPnphK5jgxzHe079QQ4pds98cUpji7RmROkRt1uQIgfWBMRq+7jwoY6PYb6VkPPvJ+sP4vVvduO2t1fb0o5YTp6fTBmD83t3wDu3j1C1v9rQ3qjjxDQjVggjHk/UCtKJob16mqSlkm+sEJppnKJdNJOQOddua1SjUDPiIp8REkYSkFhrRvwxrCE+YaR4lIFeoqNpWjewFU3tJBbjx6AuuXhr8gj1Pj46GyUmxFhjpolWZztzftTeKJ9FZhoj+IMcr6aOcyLS4ofQmHterzwAQF5mCm+7GshnhIg5VufKED7SzTHMzfHLMd3ROTcdd7271pLzh6qfWlEzRQuOnDtPIaaB799ZWZARzcBqkWZEqM52omZED8kONH8INSNGKwg7Eac8Pndf0BNd2mXg3F4dAGgT5kkzQljCrOsHSn4X61WgGfVj1OL1enDZwI6458KeivtmqchWKYymCamYU5KcUQbd7twAYrBteuTyvvj1eadh5lX9FY+L5cqsqYX/TDplMmHR0yafQ800LE6JSItH0pJ9uHF4EQpzWhNMapFN7daMkDASp0glRQKsN9MIH+pmf+zVsr+9pDe2PDkWo05rL7mP1Mv39GdbcOxUrhLhuBkaSG3XjDh4PGcHwN6FWZhxWV/kpEeH8gqJ1VgY5Dg0CwRkJ+YZ0YPdE4oYHPiap3g004SjaWzqf6mrammP3Uo1EkYSEMsHXsFDHUvNCEtGSpJsGmqp7+Z+uwfT5q8HEK2+j2hGIq9OLH1iQkRCe52HXj8PsYHTimdHzCTjRFlET5Oc+DyA43iJFuPRTGM3PfIzRbezQ5xiNA35jBCxxnIHVsHfwlWoU5BbCXy3qxJAtFYntKpjNSON/iAyLSh1rwYHLoR5bdLypIndD3+Awzu3jcSxuqawgGgUob8IED8+I078FRz4Y058RtO0EuvXcdG956CipgmnF2SJfm+3gKEF0oy4GPY583iA35zyk/j1uafZ1KJQW/gvQIvfmYOP0ov6v12V+PU/1vC2hQbSZFYYEZncrMbJeTH0jn+impEgh7N75eGaIZ0NtipCfXP0/XJibzr4FmuC4/jPazyaaeyiT2E2zju9g93NMAXSjLgYtgLMtqcuRWqSD786rwcyU1tv6xNX9cMT/91iW/tCNAdiP1mrwacwa059LzoiR8z5zg5hJIQTFz6smUaL0KSURt4s6ptEhBEHzvx6KuU68HFAkON4ZrB4dGANPT9OfB9Z3pw0HO+v2oclW4/Y3ZQoSDPiYtiVZOqp6I6QIAIAt47priqqxGyEk4qTNCOsn4iSw5aYT0k4LJr5SY0ttNJjMSsDa9uMZNmoML3UNfujtpGZxjo4TuDAGsc+Iw6XRXBR3wK89othdjdDFNKMuBg1D74dNsMoM42DfEZ8Xk/Y1KJUH0NMGAmt6tjBtclvo2bEgcOfGbVpCrJTsWLGRZY8v2JmGicu1q2Qj3rmZ2LXERMrSaqAA99pPi41I3Y3QAVOdnoHSDPiatSM03aEa7GXTEnyYopG7Yya/B+q2yL4/axpRikMUsyMExJCOJs1I05eyLO9pqWZQsFKiyBy29ndVe8rJhzHi2ZEiUXTzsELPx8c02tyAjNNII59RtzgMOrE8G+AhBFXo2ZVbMeDx15y8xNj0aODeNiZFLkZyjkp9MK2TS7sFwAq65qjtnHRVho02eHA6pBaGGLobRN7O7RqfM7o2lb1vmLRHH/9eje2Hq5BVX2zY/xHrGhFks+LNqmxV4izwl5LPJppXPSTnDhmACSMuBudmpFYPospOpKDqUmQpRf2tytpjcSStUU0I5HRp7qhxYymxQ16V4dKgvPn086R/E5LgTgpM8FlL3+LIU8uxtT316k+l9PQW5DQSjiOLwDGY2hvCIfO8zycqr0hYcTF6PUZsXooMPqw56anmNSSaDwazDRihPqOHU+3Hq4x2CrtOGTxroyGdirdjr4ds3HdUPEQ3yQN9kilpH+fbTys+lxWItTQ9OjQxpTzxlpbGuQ43vPqJB8ys9AT+RRrnKLxk4IcWF2MOp8RG8w0Bo/vnJtuSjvEYNumZKYRI/JCR17sHw7FXhgJ4dRVTggtg7Sa3yK1i5Z76TYzQWZqEmZe1Q+je+Qp7qvmcYj1EyNMBx/XmhFnv46OhjQjLubFG4cAaC1GJoVYYlCr3xejL+SDl/XBGV1zMfUCC8KSeYni9DeUXWScbIoOFbUahy9ywuhtp6TQIfFFsoYMuG5zoBxclIOfDy9Sta+a/vbGeNQPBhMhz4jdLXA/JIy4mMsGdsTWJy/FHTIZVy/onY+8zNQYtgpITzZW0bZdmxR8ePcYjDtT3QCsBb5mRPvxYg6sdo5DibYQk9KAaNGMqC2HEAxyOFLbqPq8ZhMuvmbyXY51OLg/yPE0Iw3NAVSebML1r/4PT/znh5i2xXoS7Y00DxJGXE56ivzE36sgC5/ec3aMWtNK/045AID2bazz/dCLcZ+R6Dwjdthi3WCjtgIpbZYWnxG1ZoI731mDEU+X4n+n6hTZhdmqf63nS9bgHCxGIMjx/HTuXbAew/+wBGv3VeGt5XsNndspJObbaC4kjCQAWiINzGRaSS/TzvXPX4/CY1f2M3wej0EzTVgzwkVviyWRkuWxv7YWdJtpJLZLabOs8Bn5cksFAGDut7tVn9tMrBI4tQrhXdpmGLqeMB18POKW99HJkDCSAAjt6VY7PVoxiA7onK0psZUUPDONjm4IOs5Mk1ijnzk+I/E3M4bC4c/vrVw0Tevrb3S4CAjMNIQ9OP0OkDCSAAjVrLEaGIxOk1avMnSZaUTyjNgx0Dp9YAlhdjulUvhr8hlxiTCi5bH630MXYun956Nvx2y8fNMQ2X3FnvuR3duhT2GWaMJBoxF5rZoRd/S5XsJJCG1uh5vRJYy88sorKC4uRlpaGkaOHIlVq1apOm7+/PnweDy49tpr9VyW0EmSwH1eKc+CUcwad9iif3rCcMXg+YzoCe0N/W+zmSZEvKqFpbR3UhOjlcKI3fOoGk1mZmoSuue15iG5ZkhnjO1fIH0+kW0X9MnHonvPxcDOOar21wJpRgg1aBZGFixYgOnTp2PmzJlYu3YtBg8ejLFjx+LIEfmSxHv37sX999+Pc86RzqJIWINQM2L1uBA+v9HkZxkpePmmIXh1whnhqsRGYecsXfJN2ExjrwOra1QjJiMldGi5l34Vob1O0J5Y9ViJCTdy/afnNWbPFwiSzwihjGZhZPbs2bjjjjswefJk9OvXD3PmzEFGRgbmzZsneUwgEMCECRPw+9//HqedJh2GSliDcPBRG9po+LomnOOaIZ1x+cCOJpwphDnRNDzNiOE26cfpY59eQU3qOOl7Zq5mhC0FYNf9tarKKtuF557e6mNyzRDxzLaAvvckmynpEOTktbFqnhGO47C9vDYus7dazeAurdqui/rk29wSeTQJI83NzVizZg1KSkoiJ/B6UVJSgrKyMsnjnnzySeTn5+O2227T31LCNKxWmbol7FSfzwj/f+HnWOGWPi7ITtN1nFRiLCk/VW2aEeW+a/LHvvihFGavttnn/u3JZ2LbU5fqvk9SnJ6fFf6sZKZRozV5d+U+jH3pG0x5d60ZzTOdiODovOXBh3ePwZYnx6I9k28q1pWb1aBJGKmsrEQgEEBBAd8eWVBQgPLyctFjvvvuO7z55puYO3eu6us0NTWhpqaG948wj1ipTJ2osuRVhtXRvkhtGpsdWB2uFv7b5DPx+6v7Y3BRrq7jpbQXUgKklggxzZoRm/wdrLpuflZkUvJ4PEhTSFKoVWhf//jFyEyL+HsFFEJ71dyPv37zI4BIuDWhHp/Xg4wUfuWXsQMKbWqNNJbWpqmtrcXEiRMxd+5c5OUp11UIMWvWLPz+97+3sGWJjVscWK3A6OQdrtrLbLP39zpTGrmgtzGVsJQ6Xmpi1KIZUTP5NYlUbLYLPXdYbIUe6rrivDb4v58NQvvM6KSEov4kGo35uRkpvKsHFTQjJ5v8CDRw6JAlnSnayWMKgHADnbo4EMIKutcN7YwrTDWF60OTMJKXlwefz4eKCr50WlFRgcLCaEnrxx9/xN69e3HVVVeFtwVPOY8lJSVh+/bt6NGjR9RxM2bMwPTp08N/19TUoKjI/NTgiYr1ZppWnKCyHNA5B9/ujGTQNNomkTp5FNprAdJmGm1RNqLnVpH0rNkBvglG7rGYGY/N0aK21g2g751hhZoAx8kugM54ajEAYMWMi1CYY665iFDm/rG9LS1OqhZNMm9KSgqGDRuG0tLS8LZgMIjS0lKMGjUqav8+ffpg06ZNWL9+ffjf1VdfjQsuuADr16+XFDBSU1ORnZ3N+0eYR7x7trP85sJeuJfJBGt05RKRRZzRiW5ZiWlFSmAwI8RbTTRNs5M0IybdZDWh7GJ7qOly4X1hm8xx6pzmv5NJu+90zYhJAYQxg32mnNJkzWaa6dOnY9KkSRg+fDhGjBiBl156CXV1dZg8eTIA4JZbbkHnzp0xa9YspKWlYcCAAbzjc3NzASBqOxFbOI6zLBOrk/wZ0lN8uLfkdLy0ZCcAE148LlSbJrLJHp8Rh4/OBmmREBikniktOWPUmGnUaE8sx0ATxLQZeuS4e0t6Yen2o4r7+TweBJgGC6+lpj+d5DQc77D3x6wcTkbRLIyMGzcOR48exeOPP47y8nIMGTIEixYtCju17tu3D95Y16gmNBMIcpbXrHHGI24uK3Yfx8RRxbZH04SIxz4GpPtUKh28ln7YcKBa+fq8PDIaTm4iRrJ6jujeDot+4AcVSPWdHNMu6oVlKoQRrxcAI0sIzWZ7j9UpnqOpRVob5XTh26oKy1aRkZKECSO7oskfND2SSi+6HFinTp2KqVOnin63bNky2WPfeustPZckTMZaU41zBw6j2qDPNh3GpRsO8Scro43SgXN72FqkVnFma+GcZMrU89tuGdUNmalJGNG9Hc7/4zIA+kLZPR6PKo1Ka5bniDAhvNaK3ccVz+EEP51E4unrBtrdBB6kwkhQYmFacIKZxgpe+HI7b7Vsb2hvnHayBu65sKfpK1L2ntrlH2TksUryeXHjmUUoPpUiHlDpMyKyi5pnTHhqPY+lnJ+Og2RDUbiIaoTQCQkjCYqVE6iVc/PpBZkAgD6FWQp7imPG3F1R04T/rD8U2UBmmpghtnr++bAi0wVfZ1kFzPlxYqG8arhykHLYZ7QDq/Y2y/mMOOt+EFZAwkiCYqUa2srQ3rcmj8Bd5/fA3yafafq51dLQEsCqvRG1M4X2xo6G5ugJywrlkBN8FMxqwd9uPRODu+Rgzi+GKe4r1pW3jCrGczfIq/SFwogen0h5zYj990MOq1L3JxKWJj0jnEtMJlAL3sxOuel48NI+uo+34mfLnfLAiXqs21eFKwZ21FUlWIlEs9LUiwgjgPmPGius2y2XGL3HF/TJxwUG6pL4vB5c1LcAwCbJfYQ+Inr8U+QSzdl9D9RCZlP9kDCSoFgZuuiEVaUUVrRN7pRnP7cUANDYEtCUaMrQReOY+mZ/1La41YzY3ISXbxoS/qwUiSOXZ0QtctE0TsfuexUPkJkmQbnznTWWX8OJawQrxgw1Wqay3ccsuDJpRoBTq1ELo2ncGNprBmwlXyWtXpQwoqPVC1bvx0frDoh+55a5PsFeR1MhzUiCsmqPcqidXpw8cFhiplFxTj05HmSvaerZ3IOoMALz/ZOcoBmxAykzg5KF0QyfEQC4b8EGHK1tQunWI3hr8gikp7QW8XP67XB481wBaUYI03Fy2KkVjnBqJi6zsxy6LcmSWpQeGbGCXpaYaXif7Q3tdcJrpPQuC4VtI21+ZuE2rNxzHO+u/InZ6uzpPjQGOOFeuRUSRhKE924fifN7d4jpNZ34XloRRaTmlFY4rwJwZicbYNRp7QEAeZniFVyvGdIJH9w5Cr+5sGd4mwceC5KeOWfyi6XAKXUlpRYIn289DqxCWC2Yg24HYREkjCQIo3vm4a3JI3jbxMIkzcDJ4wY7qJmlubHHTOPkXtbPyzcNxZ3n9cC/74ouvAm03rMzi9shJyOF2QakJpk7lE18c5Wp59ODk+5wm9QkXCGTbyRaM2L8eVdTQ8hpxNnaIKaQMJLA3PP+OkvP70SVpRW+AGpW0VYVo3JgFxuiQ1YqHrqsD7q1byO7H1tWyQMgKy0ZT17THx0tKEFv96rcKe/RKzefgV1PX4Zxw4sw+8bBvO+iNSPGr8fPgkvEOySMJDBLtlZYcl4nO/9Z0TKpc7L9YJXPSKLCm/xOfbxlVDEmjupm+rVs62oH3uQknxfP/WwQrj+jC3+74Pnu0jbD8LV4wogD+4LFyX5yboGEEcIynPheWuELIDVQskmcLNOMOLGTYwDrk8D6VLDhqPFCLG+x3msJNSOTxxRj4lnGBENeeLWhMxFugIQRwjKcGOkhJYuMM5CQTOqcbBInMxz61FwzUWCFO7ZrO+emY9XDF9nQIvNx0y32CR7vtGQfnrp2AHrlZ+o+Z9BFPiN254SJB0gYIUzHyROllBbjjnNPC3/+1bmn4Q/XDlB/TontbOEvs9XMiV4LQ8RKE6ZNqsnpk+xKemZD+PZlA1qdVLX63khp/pJ9kSlGqzzON9NoO5ZwHySMEJbhRAuC1JjGjqXF7dvgFxpUzEGOw/IfKzHxzZXYW1kX3t7IaEZaLEq/78Q+jgXsBC00VcVdn8Tw91x/Rme8d8dIfD7tHE3HSWn+kpkoJ60RZWyBZrf4jCTs6sAESBghTMfJYae80F5mOzuY+jS+FRwH3Dx3Jb7dWYmp768Nb29kNCP+oLl1N5w+OFuNR0Yz4kTzoB7suMcejweje+QhlwmdVoOkZoTZrjXXDkXTJBYkjBAIBDn8b1clTjZFFyGLNziJAY7vg9D6ed6tw/HoFX0Vz8kOmgdPNIQ/N/E0I9YUAYuXiVcrPAdWQReoXYD3KczCP38tns+ExW7h2g13WI2ZRhhxowTP2dzh0khEMeKGu+VMSBgh8Po3uzHhjZX45Vvfm3I+Jy/a2aZlpUV8C9gJLKROvrBPAW4/5zQowpzUzzjdNQesN9MkKnzNiL4JIMhx6NpOOQTVvkJ57kFKk2LMTOOmHiCMQsIIEa4BYVbxPCfH3HMc8PR1A3BJvwJeBA3fTKN/BccOoKwWxjLNiPO6OCZ4Zew0avskEORc0X9OfI+EPHpFXwwpysULP+cnQ0sUM42T6gi5FaraS1hoQnAeQY7DhJHdMGFkN6zYfSy83Wdg0KxrZn1DIsMmu7Dzm6wZcbL2KRbwZBGhMKLyybt5pPkJ0szETfe4IDsNH08ZE7WdNdNoFvJd5MBKGIc0I4TpJgS7bexy8MzQzGeeZsTA8ibAE0bETTZmkOh5DeTytqi5fZ1z0zF5dLGq/rPraY6HAI0kJgGJ8J4tmX6u7LEBN2lGEvx9NAMSRgi0+BPHhCAlKLGrNq3RNCw8YYT57LdI+5Soox8/AysfNV1yZnFbeL0epKf4TG2XFTjxPVJLiowD62l58gnR3JT0jDAOCSOE+at2B48hUm3jJdEyafRnx1LTtU8O7uNY4JG5X2run8/bOvRlpSXjLzcPNbVtZhEPpgkpM81rE85QNIe6KekZ+YwYh4SRBOOXY7pHbTPbZ8TJYW5StWk8JplppK5ltsAXwol9HAvkMrCq6RE2B8zY/oWy+9otFLj5DvPMNMxsc9nAjorHsvK7k02/hDmQMJJgTB5TzPvbHwjCKm2oE1cJUj+Vb6YxXxgx20yT6EMzKzzqyTPC5oNRqhuU6H1tBJ5mROOAEAyKa0YaWwKONeEk6uLADEgYSTCSBBWtmqzwF3HmOAFAnZlGazSNmmslksAXCzy8z9o7oYGJgHJ6F7ohtFeKlCQD0TQSDqxnPLUYv3hzpdGmEQ6DhJEEQ7g6eWfFT5Zdy+lDKKv6NSuahkUqssYM7DYd2I18Blbl+1ffEsk2bOR2W3kf4uEWJxnQOEolPatvDmD5j8dEv7OL0HPgYrnRdkgYSTCEA8Ksz7eZfg2323e9grdCKQRRClYAMV0YOfV/oo59Rgf9+iZGM6JkppG4dZ+sP4jBv/8SZRZNjPEQLsqaaZTMYUKU0sE7SSAnB1bjkDCSYJjlDyGHa15MlXlGeuZn4fazox1/lWAXdibXyQvjZhW+EeQ0I2qoaWxRva/UlDdt/nrUNPpx29vmlFGIR1KT9Ztp6poCqG9u1WCJLXAsMTETtkHCSIIRC2EkgnsmSl5tGpE+0rMG4yzUjLhc+WQYo7Vp+hRmm9YWqxbo8VCWPjM1kuRb69hTtvsYznluKQJBTrSP6xxU2DPSPBffLJshYSTBiIlmxPIrmA/bK2Y5sAasFEZOkaCKEdloGjW8OuEMXdetbWzBpgPVMTURuDlCo02KfmEEAI7VNWP/8XpemYUQdYypjXA/VJsmwYilZsTpEyU7vLFq/w6ZqdH7apx7mv1BXuFBs6Np3CjwmYlcnhE1FKmo1huGufmX/+lb7D/egDcnDY9c36LnPB7ucZvUSIZbvY7h5/9xmej2umY/OI7DU59uRWFOKn51bg9d5zcD15imHQwJIwmG3ICQ7DPnTXKSY5laPB7g7V+OQFV9s7aJSoIZH27Cv9ceCP9tVV6ERB37WG2B1X4zGw5UY1t5DfoUZmP/8db8JAs3lVt6TRY3T3BtGDONWRrHEPXNfuw/3oB5/9sDALhlVDEe/nATfjx6Ev++azSSjNR1IGIO3a0EQ04zkmzyy+umMdTj8eC80zvgmiGdDZ/rf7sqeYIIQKG9ZmNUM6KVS1/6lve3WYK7HPFwizNYM43JUlVdU4Dn2Prj0ZP4cN1BbDhQjTU/nTD1WkrEQ+ST3ZAwkmDIrSKFhaz04pYx1KrBfsIb0QmZrDLTuHnVbASjPiNGYQV3qy/v5lvMOrAKEy4apa7Jz8tFsu1wbfhzchJNbW6D7hgRxqzJOWI/dfMwysdo7hSpBE7GiZ8+1oJcobxYYPbEKobb8/UAQHpyxGdEa54RJeqaA7z36gCT4j8lxiYa8hkxDgkjRJgWk5NhOP29jOVgb7ZZJR5U+EYwe2LTyuGqxvBnq4SheJjg0pg8I2Y/sjUNLbxq2LVM7pjYpjAgzICEESKMWat3J86TAzq35pUY3q2tLden2jTmYvfvXvRDDB1YHSrWP3RZHwDAnedJR7G0bZMS/pzJRNaYwZOfbsGsz7eG/2YT2VmniRTHyZXK3QJF0yQgVwzqiM82Ho7aLhbLbwS7JwyWeZPOxAdrDuDG4UW6jjeqiQiYng7eiSJf7FC78H3+hkH43b83WtuYBOXX556GKwd1ROfcdMl9kn1efP9ICThwePqzrZL76eXbnZXhz7WNkSRoVuX1IayDNCMJyCs3n8HLkxCC40wKQXXgQJCfnYYpF/REh6xIDpFYNtOq6BcHyXsxRa1pxEyhTeoeWu7A6tCb7PF40KVthuK96JCVivysNFXnbM9oUrTCCiNmL6wUoUJ5hiFhJEGRsqma8RIneqSHGKZH0zhP3ospdviMSL0bVt2KeAvfVvNzurXXn+OHNdNYldeHsA4SRhIUqcHcTFsr2U8jmG3DjseIJS3065iN/KxUDOqSE7NrNttUmC2eb/GNw7vA6wGeu2Eg3rhlONqLZD9Wi52akTgoI2Q75DOSoPQpzBLd7g8GARhzNHPLgi6WzaxuaMGSLRUo6Vdg6nkTdfBLSfJi+UMXKmpIzHwWparEWnUP3PIeqUXs5zx3wyA8de0ApCa1jjn/XL1f9/n3VNaFP5NmxH2QZiRByc9Ow6f3nB213dQVvMNnyk456uzYQsaP6KrruNv/vhqr9hzHh2sPoCVA5c+NkuTzmp5iXI7jdc0xuxaQGJVgPR5PWBABzDO/me0wrkSiayrNgDQjCYyYdsQcnxF3rEp6FWThxXGDVTvXhZh1/UC8v2qfrmve+NcyAMDh6kZMuaCnrnOw0NgXO0pmfy3+hcX3IJHusdRv7dsxGwdO1PNMMXLE3IGVMAxpRhIYMSdWf8AEYSS0SjB8Juu5bmgXjOmZp7if2c6EX28/auj4eHNuJKJJxFssJYwkeT2i1bSliLWZxi0LMCdDwkgCI6ZSNNN8QCpLaczqGnISlicepoh4ucNnFisnHJR6njNSfMjLUi+MkGbEfZCZhuBhhjCSiCs6rRhNV01d7Bwsc2CNs7t884iuSE3yYkT39qqPubR/IXYcqcUz1w/E7MU7VB8Xc81IHKTutxsSRggezWZqRkw7U/xh1FGPBj/tXNQnH/XNAdxzkXFfHSEcx6E5EOQ5Y5pFvNzjJJ8X485UcP4W/NafD++Ci/q2RqBpMdPE3IE1pleLT0gYIXi0+M1LehZPmP2b4mWCcTocB/x36tn4fPNhTL2wJzJSzB/yPB4PJr65Cqv2HMeqRy5Cbob+LKIsiahhlHstcjOSVZ8n1rVpQpDZVD8kjBA8zNCMcJQaWRHDmpG4FPmsYWCXHAy0ODnad7taa6Qs2XoEPxvWxZRzJmLxNaGfGftnZqr66SrmhfLodTQMObASPCj/hThmDzZmpccggc9ZUJSTMYSPMyuIaRFG7HJgpfdRPySMEDzMTHmdSCs6rZjlM0LYj2UTUAJqGOWE9DYahBEK7XUfJIwQPMwN7TXtVHGHWWHPJPDZj9WCYSLd4aj3Qq+ZxiZpPZHuldmQMELwaAkEcaS20ZBQEo+rdjUrn8FFuarPZ9RME4ddTAhIxHscbaaJkJocma7apMhHLcXcgZWi2wxDwgjBY/PBGox4uhQ3vb7C8LkS6b2858KeePHGwar3p9De+MHqe5BQyQMFPzWPCedlw6aX3n++7Gk+31SOxpaAmS0jLIaEEYJHqObKmp9O6D5HItpPfV4PL5HZby8+XXF/M0ikeUoPbn4W41HDqARrdnzsyn4Y0DkSBZXGaEZyFMJ8y3Yfw/i5xhdUaglHPtELqRsSRggeDSasJrhITGLCkCQQRpSqyRofsxJwptLBmcXtLL9GAj3mlsO+F7ed3Z33Xefc9PDnZK/y1LVuX5VZzSJiAOUZIXiYIYyEiCfnSuEq9c7zemDO1z+G//Z5vUhiBkglM4xZpdLjqY/NZM2jJThS24TTC6IrU7sFN2t19CKf9CwFH949Gik+r6KwH2vCuZVsboebIc0IwcMM1XAiDKEPXdYH2566NPx3ktcDdrHmU3izjMoiiajC10L7zFT07Zgdk2tZdSsS0S9I6bee0bUtz3SjRKxDfAn9kDBCWEY8DaJiQ1pacsShzuf12KMZiaM+dits5IYVU18iab+0vBeX9GutWXNaXhvJfcystSVHIpqmzUaXMPLKK6+guLgYaWlpGDlyJFatWiW579y5c3HOOeegbdu2aNu2LUpKSmT3J5zDjX8t0xXim4hZKJN8fJ8RpS4wng6ecApWrb4T8R5reS3+OnEYdj19Gf5w3QDJfZpaKKO0W9AsjCxYsADTp0/HzJkzsXbtWgwePBhjx47FkSNHRPdftmwZxo8fj6VLl6KsrAxFRUW45JJLcPDgQcONJ6xl1Z7jWLpN/L7KkYiLhFbNSOQXBxWkEcN5RshG7Rh4sogFEkQiab96a/Dx8Xg8SPJ5Ud8k7efW5I9NeG8i1hEyG83CyOzZs3HHHXdg8uTJ6NevH+bMmYOMjAzMmzdPdP93330Xd999N4YMGYI+ffrgjTfeQDAYRGlpqeHGE8b5912j8JsLpUuqtwT0j66JFObWv1OOpnBdMtPED6zg+d2uStw8dwX2VtYZPm8CKhgx4axu+O3Fp+Oju0erPuZEfbPkd02nyluYWeaCsAZNwkhzczPWrFmDkpKSyAm8XpSUlKCsrEzVOerr69HS0oJ27aRD7pqamlBTU8P7R1jDsG7tMP2S3ph4VjfR73Wt4BNoEF1837mYd+twDCnK5ZtpFI4z7MBq7HDCRFih4T8bDmH5j8dw/wcbTDt/IsmbyT4v7rmoF4Z2bav6mPNO7yD5XZM/iM82Hkafxz7HJ+ut08YnorOx2WgSRiorKxEIBFBQUMDbXlBQgPLyclXnePDBB9GpUyeeQCNk1qxZyMnJCf8rKirS0kxCBw9f3hd/nTgML47jZxE1ot2IpxdTapXaqyALF/ZpfR98HvVmGvNWvXHUyQ4gLzMVk0aJC+ZSiNVBOS6zWldLIob26iE/Ow0juosvbpv8AUx5by2CHDBt/vrYNozQREyjaZ599lnMnz8fH330EdLS0iT3mzFjBqqrq8P/9u/fH8NWJibpKT6M7V+I64Z24RWk0qMZSdQhVEvuA6OFvBJRhR8L2qT68EtBsi0lxOqgsKnLdUOrbdV0zBGfT4Tmmb98tRNX/vlbVDe0mHr9kOBIt0o/moSRvLw8+Hw+VFRU8LZXVFSgsLBQ9tg//vGPePbZZ/Hll19i0KBBsvumpqYiOzub94+whz06bN/x6VypbfZXEhbMisCgicpcPDDHCZFNXW6URPK90su44eLa8yaBMPLHL3dg88Ea/GfDoVg0i9CApjcmJSUFw4YN4zmfhpxRR40aJXnc888/j6eeegqLFi3C8OHD9beWiAns2Dfr822orte3iqAxVBrjmhFSjViBx+Mx5blNM0EzQndYPaN75mHJ9PNwb0kv3nYpx9XsNHOTj5PPiHE0i+/Tp0/H3Llz8fbbb2Pr1q246667UFdXh8mTJwMAbrnlFsyYMSO8/3PPPYfHHnsM8+bNQ3FxMcrLy1FeXo6TJ0+a9ysIU0lN4j8Wmw5Wazo+HgdRrXN/MMhh4W/OiaqvEcJoifNEDJ+OBR5oM7dJYapmxLQzxTc98zORk84voHesrkl0X9YUTTgDzXdk3LhxOHr0KB5//HGUl5djyJAhWLRoUdipdd++ffAymShfe+01NDc342c/+xnvPDNnzsQTTzxhrPWEJaQIcplvOFCFs3vl6ThTYg+j/Tplo1+nfnjzuz1R35ml2CAVvsl4+H5SHo++e2WGzwhpv7Qj7Pf7FohHNfktSlRHeUb0o0s8nDp1KqZOnSr63bJly3h/7927V88lCBtJTea/0O+s+Al3n99D9cQXj2Oo1jlfqQuMakbiUv3kENgcMElej65cO2ZqRmh+U49QqyuF4fdPAAmOxqHaNEQUwhf6cHUj6pu1ZzKMp0W7ZjONwgFGfUZCxFEXOwIP+H2qN+lfWrIZmhHDp0g4UlUKgWt/OmFJdtZ4GvNiDQkjRBQpIquL43Xq8yZQfgRljEbTUA9bg8fjMUXCS1Yq26wCSjGuHbXmsTe+24Pf/tO8xHT0PhqHhBEiCjFVpyZhJORZblaDHIDWVarS/qZpRuKpkx2AB0B2WrLifkooacYIa1BrpgGATzceNv369Drqh4QRIoqzTmsfte3JT7dg3b4Tms6TyM6VSlNRkGvVjoRs13VNfk05XchGbR1pyT58/cD5GNQlB3ef30PXOczwSaBwUe1oEUYA83xH6HU0DgkjRBRTLogunLfmpxO47tXlqo6PxxdTs+lJoROCQQ43vb4CF7/4NVoCQVz4wjJc8Mdl2KwyjJpU+NYQmvi7tW+D/0w9G/ddfLqu84SiNV5eshN//GK7sTYZOjqxYJ3vs1SE75qdiZUkR/2QMEJEkZbsQyeJ9MpaSOTXUhiRJKQlEMSqvcex+2gdtpfXoqKmNR/Ckq0VsscJobHPXITCnd7qysEgh9rGFry4ZAf+snSXJjNnCPK90g6rGencNl1xf7OcWOleGYeEEUIUq+Lw3Ypah8SHLuuDwUW5uIUptiY2nzUymSGbA5HPaie/eNQ+OQFh9+vNf+YPcmhoiUx0RsxqJHCqhxVGurTNUNy/sUU8Q6te6Fbph9LQEaJIOeDtqaxD97w2sseGa9PE0Zs5raQXlv94DOPOlK8gfed5PXDneXw/gxSfN6pGRiMTKs2mrDYh+SdhInr9ngIchyZmotMj25PAqR120VDUTlkz0thikmaE/HsMQ5oRQpRHrugruv3i2V+rPkc8+TPkZ6Vh6f3nRwkaahBzqtteURv+zAojqhPLkVrY0QQCHG+iM+IoGU/vkdWwqfzVaEbe+HYPrvjTtzhaK542HgCW76rEg//aiNpGk/1LCB6kGSFEuW5oF4zpmYd3V+zDy6U7w9vVmG9omuSTmuwDGv2S39c3S3+nBK3EzMWsCDB/kOMlCvQHzTUHEOK0SYn4ap3WQV6DCwD/XnsAAPDK0l24ZVQ3eD0eFAs0vze/sRIAkJmWhMeu7Cd6HnIoNw4JI4Qk+VlpSE/Rn0mSJspWlMINTzZFJi3yGbEXs8xkQY7vM/KXr3bh2RsGaTpHPJo7rSY3IwW/v7o/PB5gQKcc1cdV1Tfjwhdatb47n75M1EfswIl609pJRENmGkKWdB1prWmi5KOUGryuKaIZUTsZhldiNFOZilnd+dW2IzhU1RD+e/73+3Wfi+6wNiaNLsYto4qRl5mi+phjTLRT5Ulxk43cQoF8RoxDwgghiy5hhAw1PF68cYjs96wtWutgRmOfuZipZn/6s628vzmOw+aD1bjhteVYvfe44vH0FhnD4/HguRsGYvyIInx492hcPbgTrhrcSXTfGsaMeqRGQhgh73JLIWGEkEVt4SkxaJXQysAuORjaNVfy+6p6RhhROxnSTOV4jglyizQHghg/dwXW/HQCP5tTpv5E9CLpZtyZXTHr+kE4o2tb/Gn8UBRJ5B6pro/cKylnVp/sfThlUtPdUoKEEUIWMtOYg1yf1BjRjNDoZypW9meTP4haGUdmIfQemU+ShHaDTUp334L1ovv4SDNiKSSMELIYyX1GnuUR2NDOc0/vwPuujnFgpdBee7HyiW3SmWCL3iLz8HnFpzzWTFPb5BdNUkc+I9ZCwgghi1hsvT8gP6jSNBkNK4y0EUQofbYpUj30f7sq0dCsPhETCXwmo2I2uXJQR12n1pp6nARO80nyqXtf6kXeQVKMWAsJI4Qs5wlW8QB4IYti0CohGjajrVy/fLXtCKbNX6d4PlLh28efxw/Fv+8ahSFFuchOU58dQZiFVwl6j8xHykwjpPJkE+56Zw1uZHx75Mw0kXtFN0svJIwQsuRnp2HtYxfztikJI0Q0WjJwfrlFuVheJLRXZ4MIUdR0p8fjwbBu7fDxlDGS0Rli6DfT0E02C7V+H3uP1ePzzeVYxUQ9yUXTkBbLOCSMEIq0a8OP11c2I1CyJiEBi1QZ1MXm0Dm3Ncri0gGFUd89eU3/8OdbRxfzvhs/oqvqa2g30xBmo1YzsvlgddQ2MtNYC2VgJTTzytJdeP5ngxX3oxVdhCCjGTFDLjFSBZaI5pOpY7B67wmU9M2P+m7iWd0wukceKk82YVi3trzvBnTOwbL7z8eh6gbcPHel7DX0Voglod48fCqrb289XBN9rAoHVkI/pBkhNPPP1QdQXS9dNIpezGhYzYip/UMTlSnkZabi0gGFSBKZrDweD3rmZ+Ks09qLpgkvzmuD/KxUxWto1ozQe2Q+Kjt1//Ho1O9qkp6R4KgfEkYIXdSoqGBJL2aEQIARRkxQwNM85SzapCormf9e9hPv7xcX78DyXZWKx9FrZB4dc8STngk5IlPFVwx6H41Dwgihiyo5zUgM2+EWtPqMqDXDkCnMGagRRr7adoT398ulO8MVYcWhN8lszu/dAXN+cQYeubyv7H6HqxujtgVVOKHT+6gfEkYIVdx0ZhHv7xP1zRJ7MtVGLW2Ru2BTs6iRM26euxIrdx/Dibpm0UgcUuE7izYp1rnfkYbRPJJ8Xlw6oCM65YprSOQsMX4ZYYTeR+OQAyuhimdvGIQP1x1E86lcCVUNZKbRQlDjaFW2+xjKXj8GAMhI8eG5GwaJhpFSHzsDn9eDJ6/pj+r6FqQme/HMwm2Gz0kTnHWkJomvw9ukJKG2STxlv5rwfHof9UOaEUI17KqhSk4zEoO2uA02a63W/qlvDuCe98UTodHY5xxuGVWMey7qpTufiBBKpGUdaRI1t9JTpGtxtQRkNCM06hmGhBFCNezC4HidtDASgQbREEZq/AihsF5n06xQLoGwnzSJauQZMsJIIKh8X2nE0w8JI4Rq2ElQztuc5spoAibnGQlBq2bnoTXtu5T6n1bb1pGaJC50ZMj4/sj5jNCtMg4JI4Rq2HfxvZX7JL3Lww6sNE+G0ZIOXgkS9pxNYXaapv1/9ffVUdv2H6/H/uMNAOg9sgJ9mhHyGbESEkYI1fTskMn7m602Kwa9lxH4ob3qiuapgfrYeUw4q6umNPGlgpDfZn8Q5zy/FGW7j5ndNOIUenxGZKNpDLeIIGGEUM2cicNQ1C4SEvfNjqOi+9GLGY2UmSY3PVnzuah/nU1qkg+zrh+o+/hqQaQa5a4wn0yJvDBSQgqgUjNC90o3JIwQqume1wZLf3t++O+sNPmJlPwZlMnNSFHeSQDru0NdHH/4VThKEsbIllgEyBXSk88zQksEo5AwQmgiyefFo1e0Zi88VifhxErvZRR3nNMdAHDNkE648VQCucFdctClbUTTtPA35yie52STn9e9tBJzLovvO1f1vre/vTo8ofkFIaQkcJqPT0LokNoOqIymoXulG0p6RmimfWbrav6T9Yew5VAN3rvjLHRgCoWFhlJ6LyM8eGkfXNyvEIOLcpCa5MMX956Lbu0z8MOhGny7sxJDinLRr1O27Dk2H6zGNa/8DzcO7xKjVhNG6FWQhQ/vHo0XvtyOx67sh3X7qjDjw02i+y7ZWoGDVQ3o0jYjKhqH3qPYISeMyOcZIYxCwgihmfZtIoLHziMncc/7azH/V6NsbJHzSfJ5MaJ7u/DfvQuzAADDurXFkunnITdD2Xfk9W92IxDk8P6q/ZGNNFM5mjO6tsW7t58FADhU1SC7b0jTr7W6L2EePhnVhpkRcUQ0ZKYhNNNfsIJfsfs46pgUyhTaq42e+ZnIy1QuQS8Vjki4g/ws+ZDfpz7dgqr65mjNCL1HMcOr22ek9X/yk9MPjW6EZtpnpuL2s7vztollZCV/BnOpPCnSx9TFrqFAIf/Il1sq8Nyi7eH6T4S19O0YbRZtIxPa29AsXrOGMAcSRghdPHplP+x99gq0a9PqP9LQElEtkzLTGjYfrLa7CYQB2rdRjpzaWVEr4jNCEqcVzL/jLLw5aThuOCPig9VGIuQXAE7Ut4Zc/2vNAZz3f0uxo6I2/B35yRmHhBHCEOmn4vLfW7kv6jtatWtn3PAiye8qT0ZHL1EXuwev1yN7fwGgMCcNTS3kMxILcjKScVHfArQwtYS6tsuQ3P9obRP+s+EQ7v9gA346Vo9HP9oc/o5Ce41DwghhiNrG1tXCW8v3htXL9F7q5w/XDZD8TsxkTTZqd3HjmfKRUIXZaeQzEmNYre7PhnXBraOLJff9DVM9Wyy1Ad0r/ZAwQhiC9TCvamj1aaACX/pJ9tErGc94FWar5CSv5kJ7hDEamiPCSJLPiyeu7q/quB+P1uG7nZUAyDRtBjTyEYZga66cqBOksaZVguVQF7sLuTwWANDiD1Job4xpMGAW+8WbK3l/0/uoHxJGCEOwmpFQRA2ZaYwxuEuO3U0gLEJJM+IPcmhqEZppaIqzErGQ+bd/OQKXDShUfxIa8wxDwghhCDYr4Yl6fugpDaL6+PttI/HW5DPRTyT0UAh1sbtQEkaaA0Ey08SYJ68ZgD6FWfjz+KHhbeed3gF3nd8j/LeCQisMjXn6IWGEMI2QMEKLBGPkpCfj/N75djeDsAA1ZhphPgua3qylR4dMLLr3XFw1uBNve5I3Mj0+e/0g2XOQn5xxSBghTGPdvipc8advw1E1NIgag0qWxx9K/sktgSCqG1rkdyJiQpIv8m6V9CvAs9cPVDyGFCP6odo0hGn8a80B3t/0Yhqjb8csbGcSK4lBfewulMw0LUEuShihe2wPrO9bss+DYd3aqtqX0AdpRghD3M3YVQlzmXlVf9w6uhgzLutjd1MIk1BjpiHNiDMIMhJGSpIXhTny6fwB0gYbgYQRwhC/vaQ3nriqn+h3ZEIwRts2KXji6v4YXJTL266mqB7hTFjNSKZI6nExMw29RfbA04x4vaL3CwD8gSBpRkyAhBHCED6vBxf2KbC7GXFNvcChsU2qdDEvwtmwVWGHds0Nfx50KpzbH+RQ0yhwYCU7jS30KshEp5w09O+UDa/XI3kfGtnoJ7pXuiGfEcIwuW2SRbfTe2kOwuqioXpAAPWx2/AxNyw7LfLepJ26p9vKa3G0NjrNOBF7kn1efP27C3j3TIzGlgBF05gAaUYIw2SlJiFJxBZO86Q5dMxJx3DGeS4tmTQjboWJFkV2emQtmJrU+oWYIEICp30k+7w8bZYYjUwGV7pV+iFhhDCMx+NBboZyeXRCP6cXZoU/sxkjyS/HXbA+I+w7ExJGCPcx48NN+OKHCrub4XroDSBMoZ2YqYbmSdNgNU9pZKZxLazKfyjjmJwiI4zQLXY2354qlgfQ+2gEEkYIUyDNiLWwK+q0JDLTuJU2qUlhLciZxe3C21OoWjOR4JADK2EKWSJhb2RCMA9WM5KewmhG7GgMoZuUJC+++d0F8Hj49zFZThih5bYjGdQlBxsPVPO20ZinHxLHCVNgB1bCfHw+1kxDr62bKchOQ35WGk/b1UYihwVAAqeT6NouAwAwukd7ZKXRWt5MaFQjTCFdJMKDFnTmIe0zQp3sVthsrH0Ks9CHcVJmOVHXLLqdiD3v3j4SUy/oiZduGoKs1Gg/OXod9UPCCGEKGSKaEXovzcPHxIRSaG98wEaMej0efDJ1jOh+2xTqExGxo6hdBu4f2xv5WWmimhEa8/RDwghhCukppLK0Ep5mJIl8RuIBnlbLA6RKOCaf1b2d6HbCXrLSxJM9EvogYYQwBXEzDU2VZsGuotNTmDwj1MVxz00jutrdBEKEoEhBmpYgZWLViy5h5JVXXkFxcTHS0tIwcuRIrFq1Snb/Dz74AH369EFaWhoGDhyIhQsX6mos4VzEzDSEebDjHplp4g85mVI20oawDWHNKACob4reRqhD81O+YMECTJ8+HTNnzsTatWsxePBgjB07FkeOHBHdf/ny5Rg/fjxuu+02rFu3Dtdeey2uvfZabN682XDjCecgFuFBi3Zr4JlpSDUSF4Tu43cPXoC//3IExvZvLT5505lFdjaLkOGeC3tFbatrDojsSahBszAye/Zs3HHHHZg8eTL69euHOXPmICMjA/PmzRPd/+WXX8all16KBx54AH379sVTTz2FM844A3/5y18MN55wDo0twahtNE+aB6v8TSMtVNwRelW6tM3Auad3wAs3DsGcXwzDE1f3t7VdhDRFp8J8WUgzoh9NwkhzczPWrFmDkpKSyAm8XpSUlKCsrEz0mLKyMt7+ADB27FjJ/QGgqakJNTU1vH+Es6kTUVkS5sEz01Adk7hDKLhnpibh0gGFZJJzGaQZ0Y+mUa2yshKBQAAFBQW87QUFBSgvLxc9pry8XNP+ADBr1izk5OSE/xUVkarS6XTISo3aRtkIrSGZhJG4g7SI8YGYHwmhDkeOajNmzEB1dXX43/79++1uEqHAz4cV4dbRxbxtbNZQwhgcY6hJUihpTriHwuw0AMCYHnk2t4Qwg7om0ozoRVNyiLy8PPh8PlRU8MslV1RUoLCwUPSYwsJCTfsDQGpqKlJTo1fahHNJSfLiiav7Y8nWChw40QAAyCAVs2mwEYNJXkeuIQgdLHvgfNQ1+dE+k8a7eKC4fbQfCaEOTaNaSkoKhg0bhtLS0vC2YDCI0tJSjBo1SvSYUaNG8fYHgMWLF0vuT7gb1rfBSyt4S0gmjVPckJbsI0EkTrj97O6YVhIdYUOoQ3PazOnTp2PSpEkYPnw4RowYgZdeegl1dXWYPHkyAOCWW25B586dMWvWLADAtGnTcN555+GFF17AFVdcgfnz52P16tV4/fXXzf0lhCMIUNIfa2CkPB8JeQThOB69sp/dTXA1moWRcePG4ejRo3j88cdRXl6OIUOGYNGiRWEn1X379sHLqJFHjx6N9957D48++igefvhh9OrVCx9//DEGDBhg3q8gHENAJCshYRy2V0/Ly7StHQRBEFagq6DI1KlTMXXqVNHvli1bFrXt5z//OX7+85/ruRThMjgSRiwnJyMZ3zxwgWiiOYIgCDdCoxlhKmSmsQahjNe1fQbyT0ViEARhD6EIwhvO6GJvQ+IAKrVKmArJItbAgTqWIJzGI1f0xaUDCjG0a67dTXE9pBkhTCVUU6NXPvk1mMnwYiojTxBOI9nnxVmntUdqEqUxMAppRghTefyq/hjQOQeX9pfOI0No5/zTO+D1icPQuzDL7qYQBEGYDgkjhKlkpibhllHFdjcj7vB4PLiEBDyCIOIUMtMQBEEQBGErJIwQBEEQBGErJIwQBEEQBGErJIwQBEEQBGErJIwQBEEQBGErJIwQBEEQBGErJIwQBEEQBGErJIwQBEEQBGErJIwQBEEQBGErJIwQBEEQBGErJIwQBEEQBGErJIwQBEEQBGErJIwQBEEQBGErrqjay3EcAKCmpsbmlhAEQRAEoZbQvB2ax6VwhTBSW1sLACgqKrK5JQRBEARBaKW2thY5OTmS33s4JXHFAQSDQRw6dAhZWVnweDymnbempgZFRUXYv38/srOzTTsvEQ31dWygfo4N1M+xgfo5dljV1xzHoba2Fp06dYLXK+0Z4grNiNfrRZcuXSw7f3Z2Nj3oMYL6OjZQP8cG6ufYQP0cO6zoazmNSAhyYCUIgiAIwlZIGCEIgiAIwlYSWhhJTU3FzJkzkZqaandT4h7q69hA/RwbqJ9jA/Vz7LC7r13hwEoQBEEQRPyS0JoRgiAIgiDsh4QRgiAIgiBshYQRgiAIgiBshYQRgiAIgiBsJaGFkVdeeQXFxcVIS0vDyJEjsWrVKrub5BpmzZqFM888E1lZWcjPz8e1116L7du38/ZpbGzElClT0L59e2RmZuKGG25ARUUFb599+/bhiiuuQEZGBvLz8/HAAw/A7/fH8qe4imeffRYejwf33ntveBv1s3kcPHgQv/jFL9C+fXukp6dj4MCBWL16dfh7juPw+OOPo2PHjkhPT0dJSQl27tzJO8fx48cxYcIEZGdnIzc3F7fddhtOnjwZ65/iWAKBAB577DF0794d6enp6NGjB5566ile7RLqZ3188803uOqqq9CpUyd4PB58/PHHvO/N6teNGzfinHPOQVpaGoqKivD8888bbzyXoMyfP59LSUnh5s2bx/3www/cHXfcweXm5nIVFRV2N80VjB07lvvb3/7Gbd68mVu/fj13+eWXc127duVOnjwZ3ufOO+/kioqKuNLSUm716tXcWWedxY0ePTr8vd/v5wYMGMCVlJRw69at4xYuXMjl5eVxM2bMsOMnOZ5Vq1ZxxcXF3KBBg7hp06aFt1M/m8Px48e5bt26cbfeeiu3cuVKbvfu3dwXX3zB7dq1K7zPs88+y+Xk5HAff/wxt2HDBu7qq6/munfvzjU0NIT3ufTSS7nBgwdzK1as4L799luuZ8+e3Pjx4+34SY7k6aef5tq3b899+umn3J49e7gPPviAy8zM5F5++eXwPtTP+li4cCH3yCOPcB9++CEHgPvoo49435vRr9XV1VxBQQE3YcIEbvPmzdz777/Ppaenc3/9618NtT1hhZERI0ZwU6ZMCf8dCAS4Tp06cbNmzbKxVe7lyJEjHADu66+/5jiO46qqqrjk5GTugw8+CO+zdetWDgBXVlbGcVzri+P1erny8vLwPq+99hqXnZ3NNTU1xfYHOJza2lquV69e3OLFi7nzzjsvLIxQP5vHgw8+yJ199tmS3weDQa6wsJD7v//7v/C2qqoqLjU1lXv//fc5juO4LVu2cAC477//PrzP559/znk8Hu7gwYPWNd5FXHHFFdwvf/lL3rbrr7+emzBhAsdx1M9mIRRGzOrXV199lWvbti1v7HjwwQe53r17G2pvQpppmpubsWbNGpSUlIS3eb1elJSUoKyszMaWuZfq6moAQLt27QAAa9asQUtLC6+P+/Tpg65du4b7uKysDAMHDkRBQUF4n7Fjx6KmpgY//PBDDFvvfKZMmYIrrriC158A9bOZ/Oc//8Hw4cPx85//HPn5+Rg6dCjmzp0b/n7Pnj0oLy/n9XVOTg5GjhzJ6+vc3FwMHz48vE9JSQm8Xi9WrlwZux/jYEaPHo3S0lLs2LEDALBhwwZ89913uOyyywBQP1uFWf1aVlaGc889FykpKeF9xo4di+3bt+PEiRO62+eKQnlmU1lZiUAgwBucAaCgoADbtm2zqVXuJRgM4t5778WYMWMwYMAAAEB5eTlSUlKQm5vL27egoADl5eXhfcTuQeg7opX58+dj7dq1+P7776O+o342j927d+O1117D9OnT8fDDD+P777/Hb37zG6SkpGDSpEnhvhLrS7av8/Pzed8nJSWhXbt21NeneOihh1BTU4M+ffrA5/MhEAjg6aefxoQJEwCA+tkizOrX8vJydO/ePeocoe/atm2rq30JKYwQ5jJlyhRs3rwZ3333nd1NiTv279+PadOmYfHixUhLS7O7OXFNMBjE8OHD8cwzzwAAhg4dis2bN2POnDmYNGmSza2LH/75z3/i3XffxXvvvYf+/ftj/fr1uPfee9GpUyfq5wQmIc00eXl58Pl8UREHFRUVKCwstKlV7mTq1Kn49NNPsXTpUnTp0iW8vbCwEM3NzaiqquLtz/ZxYWGh6D0IfUe0mmGOHDmCM844A0lJSUhKSsLXX3+NP/3pT0hKSkJBQQH1s0l07NgR/fr1423r27cv9u3bByDSV3LjRmFhIY4cOcL73u/34/jx49TXp3jggQfw0EMP4aabbsLAgQMxceJE3HfffZg1axYA6merMKtfrRpPElIYSUlJwbBhw1BaWhreFgwGUVpailGjRtnYMvfAcRymTp2Kjz76CF999VWU2m7YsGFITk7m9fH27duxb9++cB+PGjUKmzZt4j38ixcvRnZ2dtSkkKhcdNFF2LRpE9avXx/+N3z4cEyYMCH8mfrZHMaMGRMVnr5jxw5069YNANC9e3cUFhby+rqmpgYrV67k9XVVVRXWrFkT3uerr75CMBjEyJEjY/ArnE99fT28Xv7U4/P5EAwGAVA/W4VZ/Tpq1Ch88803aGlpCe+zePFi9O7dW7eJBkBih/ampqZyb731FrdlyxbuV7/6FZebm8uLOCCkueuuu7icnBxu2bJl3OHDh8P/6uvrw/vceeedXNeuXbmvvvqKW716NTdq1Chu1KhR4e9DIaeXXHIJt379em7RokVchw4dKORUATaahuOon81i1apVXFJSEvf0009zO3fu5N59910uIyODe+edd8L7PPvss1xubi73ySefcBs3buSuueYa0dDIoUOHcitXruS+++47rlevXgkfcsoyadIkrnPnzuHQ3g8//JDLy8vjfve734X3oX7WR21tLbdu3Tpu3bp1HABu9uzZ3Lp167iffvqJ4zhz+rWqqoorKCjgJk6cyG3evJmbP38+l5GRQaG9Rvjzn//Mde3alUtJSeFGjBjBrVixwu4muQYAov/+9re/hfdpaGjg7r77bq5t27ZcRkYGd91113GHDx/mnWfv3r3cZZddxqWnp3N5eXncb3/7W66lpSXGv8ZdCIUR6mfz+O9//8sNGDCAS01N5fr06cO9/vrrvO+DwSD32GOPcQUFBVxqaip30UUXcdu3b+ftc+zYMW78+PFcZmYml52dzU2ePJmrra2N5c9wNDU1Ndy0adO4rl27cmlpadxpp53GPfLII7xQUepnfSxdulR0XJ40aRLHceb164YNG7izzz6bS01N5Tp37sw9++yzhtvu4Tgm7R1BEARBEESMSUifEYIgCIIgnAMJIwRBEARB2AoJIwRBEARB2AoJIwRBEARB2AoJIwRBEARB2AoJIwRBEARB2AoJIwRBEARB2AoJIwRBEARB2AoJIwRBEARB2AoJIwRBEARB2AoJIwRBEARB2AoJIwRBEARB2Mr/A7RC4/cxl40YAAAAAElFTkSuQmCC\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Check R2-score\n",
        "r2_score(y_val, y_pred)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "grMkesMXTku2",
        "outputId": "af0a5476-5370-41d7-bc86-59f7884b3d77"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.7251691563138285"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "y_train_pred = best_model.predict(x_train)"
      ],
      "metadata": {
        "id": "SZVtS6xo0kYu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Nx(TD) for fully connected NN."
      ],
      "metadata": {
        "id": "WHBm4luJraCu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tf.keras.backend.clear_session()"
      ],
      "metadata": {
        "id": "S-CGO6naXoDu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# FC_ANN\n",
        "model_FCN = tf.keras.models.Sequential([\n",
        "    tf.keras.layers.Dense(16, activation='relu', input_shape=(T*D,)),\n",
        "    tf.keras.layers.Dense(8, activation='relu'),\n",
        "    tf.keras.layers.Dense(K)\n",
        "])"
      ],
      "metadata": {
        "id": "I-74CwmNrWxM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model_FCN.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bNGGrY4mZjIZ",
        "outputId": "52ab81aa-8c3a-491a-bdb7-633c0e19622e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "dense (Dense)                (None, 16)                1296      \n",
            "_________________________________________________________________\n",
            "dense_1 (Dense)              (None, 8)                 136       \n",
            "_________________________________________________________________\n",
            "dense_2 (Dense)              (None, 1)                 9         \n",
            "=================================================================\n",
            "Total params: 1,441\n",
            "Trainable params: 1,441\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model = model_FCN\n",
        "model = compile(model)\n",
        "check_point = ModelCheckpoint(\n",
        "    'best_model_FCN.h5', monitor='val_loss', save_best_only=True)\n",
        "early_stopping = EarlyStopping(monitor='val_loss', patience=200)\n",
        "\n",
        "history = model.fit(NT_x_train, NT_y_train, epochs=1000, \n",
        "                    validation_data=(NT_x_val, NT_y_val),\n",
        "                    callbacks=[check_point, early_stopping],\n",
        "                    verbose=2)\n",
        "\n",
        "# Load best model\n",
        "best_model = tf.keras.models.load_model('best_model_FCN.h5')\n",
        "\n",
        "# Make predictions with best model \n",
        "y_pred = best_model.predict(NT_x_val)\n",
        "\n",
        "# Evaluate with best model\n",
        "val_loss = best_model.evaluate(NT_x_val, NT_y_val)"
      ],
      "metadata": {
        "id": "uP9xHiBIPJas"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "val_loss"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Z9c1nxc1UflL",
        "outputId": "fa0c4d7a-7cc7-4e73-b160-64055ca6d9dd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.14104200899600983"
            ]
          },
          "metadata": {},
          "execution_count": 81
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plot_loss_accuracy(filename='ANN for health index prediction')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 469
        },
        "id": "xe90jAwEUWZc",
        "outputId": "a21bd8ce-8348-46c5-9ef0-b389a4839b05"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 0 Axes>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Comment: Observation from this method shows the effect of too many features influenced majorly by the dimensions of the input data and the model type. Fully connected NN's don't have the weight sharing capability like CNNs and RNNs so they can easily overfit. "
      ],
      "metadata": {
        "id": "CtfsJF9CaxeG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Use Prepared dataset NxTxD to train Multi-tail-ANN, CNN and LSTM networks"
      ],
      "metadata": {
        "id": "GT4UEkNzeZxY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "T = 10\n",
        "D = 8\n",
        "K = 1"
      ],
      "metadata": {
        "id": "uvchDKYLpw3J"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "tf.keras.backend.clear_session()"
      ],
      "metadata": {
        "id": "C_tyftX2ZO66"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# The ANN Model development - Multi-Input/Multi-tail ANN\n",
        "# You have to keep track of the input and the output of the model\n",
        "inputs = []\n",
        "features = []\n",
        "\n",
        "# Build a dense ANN model for each feature - \n",
        "# If you use the input layers in a for loop, different unique instances of the symbolic tensors are automatically created - So they can have their unique function flow\n",
        "for _ in range(D):\n",
        "  i = Input(shape=(T,))\n",
        "  x = Dense(5, activation='relu')(i)\n",
        "  inputs.append(i)\n",
        "  features.append(x)\n",
        "\n",
        "# recall, we want to concatenate the outputs of the multi-unit ANN models\n",
        "# N x (FxD)\n",
        "x = Concatenate()(features)\n",
        "# Now start working on this\n",
        "x = Dense(16, activation='relu')(x)\n",
        "x = Dense(K)(x)\n",
        "\n",
        "# Instantiate Model\n",
        "model_ANN = Model(inputs, x)"
      ],
      "metadata": {
        "id": "aFOi_DIZpqch"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x_trains = []\n",
        "for k in range(D):\n",
        "  l = NT_x_train[:,k*10:k*10+10]\n",
        "  x_trains.append(l)\n",
        "len(x_trains)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0sdM9aXLdDnr",
        "outputId": "c6d7b0e3-9610-4575-8ac7-381239ab063e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "8"
            ]
          },
          "metadata": {},
          "execution_count": 92
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x_trains[0].shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-Z8wAXjle5hk",
        "outputId": "1aace639-cb6f-4e46-def6-603b0f1e58f5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(41447, 10)"
            ]
          },
          "metadata": {},
          "execution_count": 94
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x_vals = []\n",
        "for k in range(D):\n",
        "  l = NT_x_val[:,k*10:k*10+10]\n",
        "  x_vals.append(l)\n",
        "len(x_vals)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qdC2-zRnekLC",
        "outputId": "905bf581-56a1-42a6-d679-ca9f86299c23"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "8"
            ]
          },
          "metadata": {},
          "execution_count": 95
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x_vals[0].shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uPFmKuarfWRp",
        "outputId": "00d7a25f-a7c5-4bcd-8551-818be806682a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(12294, 10)"
            ]
          },
          "metadata": {},
          "execution_count": 96
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model = model_ANN\n",
        "model = compile(model)\n",
        "check_point = ModelCheckpoint(\n",
        "    'best_model_ANN.h5', monitor='val_loss', save_best_only=True)\n",
        "early_stopping = EarlyStopping(monitor='val_loss', patience=200)\n",
        "\n",
        "history = model.fit(x_trains, NT_y_train, epochs=1000, \n",
        "                    validation_data=(x_vals, NT_y_val),\n",
        "                    callbacks=[check_point, early_stopping],\n",
        "                    verbose=2)\n",
        "\n",
        "# Load best model\n",
        "best_model = tf.keras.models.load_model('best_model_ANN.h5')\n",
        "\n",
        "# Make predictions with best model \n",
        "y_pred = best_model.predict(x_vals)\n",
        "\n",
        "# Evaluate with best model\n",
        "val_loss = best_model.evaluate(x_vals, y_val)"
      ],
      "metadata": {
        "id": "O2sPE1Uvf1Y4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "val_loss"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9b551091-195a-4f60-b145-90e76247fe4f",
        "id": "ZX96kdYSlNuO"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.14104200899600983"
            ]
          },
          "metadata": {},
          "execution_count": 102
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plot_loss_accuracy(filename='ANN for health index prediction')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 469
        },
        "outputId": "a7a3d204-afc6-404a-fda8-739ffb074330",
        "id": "MD40yV9OlNuO"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 0 Axes>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Build CNN and LSTM Models"
      ],
      "metadata": {
        "id": "NNweQjPlf5GW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# CNN Model - 1D Convnet\n",
        "model_CNN = tf.keras.Sequential([\n",
        "  tf.keras.layers.Conv1D(32, 3, activation='relu', padding='same', input_shape=(T,D)),\n",
        "  tf.keras.layers.MaxPooling1D(),\n",
        "  tf.keras.layers.Conv1D(64, 3, activation='relu', padding='same'),\n",
        "  tf.keras.layers.MaxPooling1D(),\n",
        "  tf.keras.layers.Conv1D(128, 3, activation='relu', padding='same'),\n",
        "  tf.keras.layers.MaxPooling1D(),\n",
        "  tf.keras.layers.Flatten(),  \n",
        "  tf.keras.layers.Dense(16, activation='relu'),\n",
        "  tf.keras.layers.Dense(K)\n",
        "])\n",
        "\n",
        "# LSTM Model\n",
        "model_LSTM = tf.keras.Sequential([\n",
        "  tf.keras.layers.LSTM(32, return_sequences=True, input_shape=(T,D)),\n",
        "  tf.keras.layers.LSTM(24, return_sequences=True),\n",
        "  tf.keras.layers.LSTM(16),\n",
        "  tf.keras.layers.Dense(K)  \n",
        "])"
      ],
      "metadata": {
        "id": "LJwMOqWXUgZg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model_CNN.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mdzjkbbQoBqE",
        "outputId": "6bc04441-470e-44e4-dcb5-85a3ca65d722"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_2\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "conv1d_6 (Conv1D)            (None, 10, 32)            800       \n",
            "_________________________________________________________________\n",
            "max_pooling1d_6 (MaxPooling1 (None, 5, 32)             0         \n",
            "_________________________________________________________________\n",
            "conv1d_7 (Conv1D)            (None, 5, 64)             6208      \n",
            "_________________________________________________________________\n",
            "max_pooling1d_7 (MaxPooling1 (None, 2, 64)             0         \n",
            "_________________________________________________________________\n",
            "conv1d_8 (Conv1D)            (None, 2, 128)            24704     \n",
            "_________________________________________________________________\n",
            "max_pooling1d_8 (MaxPooling1 (None, 1, 128)            0         \n",
            "_________________________________________________________________\n",
            "flatten_2 (Flatten)          (None, 128)               0         \n",
            "_________________________________________________________________\n",
            "dense_14 (Dense)             (None, 16)                2064      \n",
            "_________________________________________________________________\n",
            "dense_15 (Dense)             (None, 1)                 17        \n",
            "=================================================================\n",
            "Total params: 33,793\n",
            "Trainable params: 33,793\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Compile, Fit, Plot costs and Evaluate models."
      ],
      "metadata": {
        "id": "T4Czfd9Lt9Fe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# CNN and LSTM train\n",
        "history = {}\n",
        "y_preds = []\n",
        "val_losses = []\n",
        "models = [model_CNN, model_LSTM]\n",
        "names = ['CNN','LSTM']\n",
        "\n",
        "for idx, name in enumerate(names):\n",
        "  # instantiate call backs\n",
        "  check_point = ModelCheckpoint('best_model_'+name+'.h5', monitor='val_loss', save_best_only=True)\n",
        "  early_stopping = EarlyStopping(monitor='val_loss', patience=10)\n",
        "\n",
        "  # Compile Model\n",
        "  model = compile(models[idx])\n",
        "\n",
        "  # Fit Model\n",
        "  history[name] = model.fit(NTD_x_train, NT_y_train, epochs=30, \n",
        "                      validation_data=(NTD_x_val, NT_y_val),\n",
        "                      callbacks=[check_point, early_stopping],\n",
        "                      verbose=2)\n",
        "  \n",
        "  # Get best model from current model\n",
        "  best_model = tf.keras.models.load_model('best_model_'+name+'.h5')\n",
        "\n",
        "  # Make predictions with best model \n",
        "  y_pred = best_model.predict(NTD_x_val)\n",
        "  y_preds.append(y_pred)\n",
        "\n",
        "  # Evaluate with best model\n",
        "  val_loss = best_model.evaluate(NTD_x_val, NT_y_val)\n",
        "  val_losses.append(val_loss)\n",
        "\n",
        "  tf.keras.backend.clear_session()\n",
        "\n",
        "# Plot metric\n",
        "plotter = tfdocs.plots.HistoryPlotter(metric = 'loss', smoothing_std=10)\n",
        "plotter.plot(history)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "22sH9Ga2unP5",
        "outputId": "ab242be7-5b4f-4a53-d41e-7a62d2a738ea"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/30\n",
            "1296/1296 - 7s - loss: 0.0014 - val_loss: 0.1594\n",
            "Epoch 2/30\n",
            "1296/1296 - 5s - loss: 0.0014 - val_loss: 0.1615\n",
            "Epoch 3/30\n",
            "1296/1296 - 5s - loss: 0.0013 - val_loss: 0.1597\n",
            "Epoch 4/30\n",
            "1296/1296 - 6s - loss: 0.0014 - val_loss: 0.1641\n",
            "Epoch 5/30\n",
            "1296/1296 - 6s - loss: 0.0013 - val_loss: 0.1628\n",
            "Epoch 6/30\n",
            "1296/1296 - 6s - loss: 0.0013 - val_loss: 0.1628\n",
            "Epoch 7/30\n",
            "1296/1296 - 6s - loss: 0.0013 - val_loss: 0.1668\n",
            "Epoch 8/30\n",
            "1296/1296 - 6s - loss: 0.0013 - val_loss: 0.1584\n",
            "Epoch 9/30\n",
            "1296/1296 - 6s - loss: 0.0013 - val_loss: 0.1641\n",
            "Epoch 10/30\n",
            "1296/1296 - 6s - loss: 0.0013 - val_loss: 0.1590\n",
            "Epoch 11/30\n",
            "1296/1296 - 6s - loss: 0.0013 - val_loss: 0.1626\n",
            "Epoch 12/30\n",
            "1296/1296 - 6s - loss: 0.0013 - val_loss: 0.1587\n",
            "Epoch 13/30\n",
            "1296/1296 - 6s - loss: 0.0013 - val_loss: 0.1585\n",
            "Epoch 14/30\n",
            "1296/1296 - 6s - loss: 0.0013 - val_loss: 0.1645\n",
            "Epoch 15/30\n",
            "1296/1296 - 6s - loss: 0.0013 - val_loss: 0.1582\n",
            "Epoch 16/30\n",
            "1296/1296 - 6s - loss: 0.0013 - val_loss: 0.1622\n",
            "Epoch 17/30\n",
            "1296/1296 - 6s - loss: 0.0013 - val_loss: 0.1641\n",
            "Epoch 18/30\n",
            "1296/1296 - 6s - loss: 0.0013 - val_loss: 0.1599\n",
            "Epoch 19/30\n",
            "1296/1296 - 6s - loss: 0.0013 - val_loss: 0.1605\n",
            "Epoch 20/30\n",
            "1296/1296 - 6s - loss: 0.0012 - val_loss: 0.1611\n",
            "Epoch 21/30\n",
            "1296/1296 - 6s - loss: 0.0012 - val_loss: 0.1587\n",
            "Epoch 22/30\n",
            "1296/1296 - 6s - loss: 0.0013 - val_loss: 0.1605\n",
            "Epoch 23/30\n",
            "1296/1296 - 6s - loss: 0.0012 - val_loss: 0.1595\n",
            "Epoch 24/30\n",
            "1296/1296 - 6s - loss: 0.0012 - val_loss: 0.1636\n",
            "Epoch 25/30\n",
            "1296/1296 - 6s - loss: 0.0012 - val_loss: 0.1626\n",
            "385/385 [==============================] - 1s 2ms/step - loss: 0.1582\n",
            "Epoch 1/30\n",
            "1296/1296 - 14s - loss: 0.0222 - val_loss: 0.1457\n",
            "Epoch 2/30\n",
            "1296/1296 - 12s - loss: 0.0169 - val_loss: 0.1489\n",
            "Epoch 3/30\n",
            "1296/1296 - 12s - loss: 0.0163 - val_loss: 0.1507\n",
            "Epoch 4/30\n",
            "1296/1296 - 12s - loss: 0.0161 - val_loss: 0.1459\n",
            "Epoch 5/30\n",
            "1296/1296 - 12s - loss: 0.0158 - val_loss: 0.1500\n",
            "Epoch 6/30\n",
            "1296/1296 - 12s - loss: 0.0157 - val_loss: 0.1590\n",
            "Epoch 7/30\n",
            "1296/1296 - 12s - loss: 0.0155 - val_loss: 0.1475\n",
            "Epoch 8/30\n",
            "1296/1296 - 12s - loss: 0.0153 - val_loss: 0.1494\n",
            "Epoch 9/30\n",
            "1296/1296 - 12s - loss: 0.0151 - val_loss: 0.1499\n",
            "Epoch 10/30\n",
            "1296/1296 - 12s - loss: 0.0148 - val_loss: 0.1528\n",
            "Epoch 11/30\n",
            "1296/1296 - 12s - loss: 0.0146 - val_loss: 0.1512\n",
            "385/385 [==============================] - 2s 5ms/step - loss: 0.1457\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "val_losses"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vPJepIhPHvnF",
        "outputId": "1b5a8b44-6234-4b8b-acb5-af1b7fd5c383"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0.15819191932678223, 0.14574983716011047]"
            ]
          },
          "metadata": {},
          "execution_count": 111
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "y_preds[0].shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-BqvTzSZHx0l",
        "outputId": "d22342cd-0df3-4224-9c5b-06ce95d53663"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(12294, 1)"
            ]
          },
          "metadata": {},
          "execution_count": 112
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Thoughts and comments on above models.\n",
        "\n",
        "\n",
        "*   ANN + orig_data: This had the best result initially but after much tuning, it shows that there is so much the fully connected ANN can do with this problem. Increasing the layers will just result in more overfitting but not enable the network to learn better. The drastic drop in loss within very few epochs also shows this.\n",
        "\n",
        "*   ANN + NT_Data: Just as expected, there is so much an ANN can do for this problem and we have too many parameters so the overfit was terrible.\n",
        "*  Multi-tail ANN + NTD_Data: Acted just like the ANN + NT_Data model.\n",
        "\n",
        "*   CNN + NTD_Data: This is particularly interesting, eventhough there was tremendous overfitting due to too many parameters, the train loss was much lower than we got with ANN and multi-tail ANN. This shows than CNN has the capacity to extract better features from the data if it is trained and finetuned properly.\n",
        "\n",
        "\n",
        "*   LSTM + NTD_Data: Surprisingly, LSTM doesn't do much better than ANN.\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "dh7w1RukznTr"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Training and Finetuning Selected Baseline Models for better performance. "
      ],
      "metadata": {
        "id": "OmK3xvO2TD-2"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Fully Connected ANN Model with NxD dataset - Add regularization and use keras tuner to tune learning rate, No of activation units and regularization parameter."
      ],
      "metadata": {
        "id": "cGL3ijDQS_CK"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Prepare datasets for use in tensorflow - Build data input pipeline.\n",
        "\n",
        "\n",
        "* If all of your input data fits in memory, the simplest way to create a Dataset from numpy arrays is to convert them to tf.Tensor objects and use Dataset.from_tensor_slices. This returns a tf.data.Dataset that can slice up the dictionary of features. You can iterate over a tf.data.Dataset like any other python iterable.\n",
        "\n",
        "*   Batch and configure data - Do not shuffle the dataset.\n",
        "For timeseries data, we want to mantain the order of the data when feeding it to the network.\n",
        "\n"
      ],
      "metadata": {
        "id": "Rya1wrYQX_xu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a tf Dataset for numpy array and batch\n",
        "BATCH_SIZE = 64\n",
        "train_dataset = tf.data.Dataset.from_tensor_slices((x_train,y_train)).batch(BATCH_SIZE) \n",
        "val_dataset = tf.data.Dataset.from_tensor_slices((x_val,y_val)).batch(BATCH_SIZE) "
      ],
      "metadata": {
        "id": "V2eqLOC8ZSKS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# ANN Model\n",
        "def model_builder(hp):\n",
        "  FC_ANN_R = tf.keras.models.Sequential([\n",
        "      \n",
        "      tf.keras.layers.Dense(units=hp.Choice('neurons_1', values=[32, 64, 96]), activation='relu', kernel_initializer='he_uniform',\n",
        "                            kernel_regularizer=regularizers.L2(hp.Choice('reg_rate1', values=[0.00 , 1e-2 , 3e-3 , 1e-3])), input_shape=(D,)),\n",
        "      tf.keras.layers.Dense(units=hp.Choice('neurons_2', values=[32, 64, 96]), activation='relu', kernel_initializer='he_uniform',\n",
        "                            kernel_regularizer=regularizers.L2(hp.Choice('reg_rate2', values=[0.00 , 1e-2 , 3e-3 , 1e-3]))),\n",
        "      tf.keras.layers.Dense(K)\n",
        "  ])\n",
        "  # Tune the learning rate for the optimizer\n",
        "  # Choose an optimal value from 0.01, 0.001, or 0.0001\n",
        "  hp_learning_rate = hp.Choice('learning_rate', values=[1e-2, 3e-2, 1e-3, 3e-3])\n",
        "\n",
        "  model.compile(optimizer=keras.optimizers.Adam(learning_rate=hp_learning_rate),\n",
        "                loss='mse')\n",
        "  return model"
      ],
      "metadata": {
        "id": "qw8WamSdS_CL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Use the hyperband tuner\n",
        "tuner_ANN = kt.Hyperband(model_builder,\n",
        "                    objective='val_loss',\n",
        "                    max_epochs=100,\n",
        "                    factor=3,\n",
        "                    directory='FC_ANN_R',\n",
        "                    project_name='NASA_HI'\n",
        "                    )\n",
        "tuner_ANN.search_space_summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cBe3NHyYfPhC",
        "outputId": "bfaf30b0-8bd5-45d1-88ee-295c10d3db80"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "INFO:tensorflow:Reloading Tuner from FC_ANN_R\\NASA_HI\\tuner0.json\n",
            "Search space summary\n",
            "Default search space size: 5\n",
            "neurons_1 (Choice)\n",
            "{'default': 32, 'conditions': [], 'values': [32, 64, 96], 'ordered': True}\n",
            "reg_rate1 (Choice)\n",
            "{'default': 0.0, 'conditions': [], 'values': [0.0, 0.01, 0.003, 0.001], 'ordered': True}\n",
            "neurons_2 (Choice)\n",
            "{'default': 32, 'conditions': [], 'values': [32, 64, 96], 'ordered': True}\n",
            "reg_rate2 (Choice)\n",
            "{'default': 0.0, 'conditions': [], 'values': [0.0, 0.01, 0.003, 0.001], 'ordered': True}\n",
            "learning_rate (Choice)\n",
            "{'default': 0.01, 'conditions': [], 'values': [0.01, 0.03, 0.001, 0.003], 'ordered': True}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Instantiate callbacks\n",
        "early_stopping = EarlyStopping(monitor='val_loss', patience=50)\n",
        "\n",
        "# Search - Takes in the same hyperparameters as fit\n",
        "tuner_ANN.search(train_dataset, epochs=100, validation_data=val_dataset,\n",
        "                 callbacks=[early_stopping] )"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TBjFXqbYhm6N",
        "outputId": "12a0532e-fde6-429f-e4a8-644a7c9c5f85"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Trial 246 Complete [00h 01m 45s]\n",
            "val_loss: 0.038887787610292435\n",
            "\n",
            "Best val_loss So Far: 0.02269602008163929\n",
            "Total elapsed time: 01h 14m 49s\n",
            "INFO:tensorflow:Oracle triggered exit\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Shows the 10 best trials\n",
        "tuner_ANN.results_summary()"
      ],
      "metadata": {
        "id": "fu5xcDPYjp8Y"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "best_hps = tuner_ANN.get_best_hyperparameters(num_trials = 1)[0]"
      ],
      "metadata": {
        "id": "HwwMZHVDjdko"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "best_hps['reg_rate2']"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ub5p4jjLjfJ8",
        "outputId": "362460a0-6fa9-4de0-9cd2-e70c3e0a0941"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.003"
            ]
          },
          "metadata": {},
          "execution_count": 44
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model_ANN = tuner_ANN.hypermodel.build(best_hps)\n",
        "# Retrain the model\n",
        "history =  model_ANN.fit(train_dataset, epochs=100, validation_data=val_dataset, callbacks=[early_stopping])"
      ],
      "metadata": {
        "id": "Zs8RCuBkjvoA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Compile, fit and plot\n",
        "# history = compile_and_fit(model, optimizer=None, max_epochs=70)\n",
        "plot_loss_accuracy(filename='ANN + Orig_data')\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 469
        },
        "id": "uz85Vfgsj4UL",
        "outputId": "9b9c84bb-86c3-4ced-c074-524a92321cf5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 0 Axes>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Make predictions with best model \n",
        "y_pred = model_ANN.predict(val_dataset)\n",
        "\n",
        "# Check R2-score on validation set\n",
        "r2_score(y_val, y_pred)"
      ],
      "metadata": {
        "id": "6JtHRNrRj4vP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "14719c02-c4af-4f20-f3cd-23700a832f71"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.7205925175441565"
            ]
          },
          "metadata": {},
          "execution_count": 55
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Comment: It can only fit the data to an r2-score of about 73% and we need something as good as 90-95%."
      ],
      "metadata": {
        "id": "qLDkZDnI348s"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# CNN + NTD_Data."
      ],
      "metadata": {
        "id": "PRnNxTr459ht"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "T = 5\n",
        "D = 8\n",
        "K = 1"
      ],
      "metadata": {
        "id": "Uxu2QWrvCK_E"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# CNN Model - 1D Convnet\n",
        "model_CNN = tf.keras.Sequential([\n",
        "  tf.keras.layers.Conv1D(32, 3, activation='relu', padding='same', input_shape=(T,D)),\n",
        "  tf.keras.layers.MaxPooling1D(),\n",
        "  tf.keras.layers.Conv1D(64, 3, activation='relu', padding='same'),\n",
        "  tf.keras.layers.MaxPooling1D(),\n",
        "  # tf.keras.layers.Conv1D(128, 3, activation='relu', padding='same'),\n",
        "  # tf.keras.layers.MaxPooling1D(),\n",
        "  tf.keras.layers.Flatten(),  \n",
        "  tf.keras.layers.Dense(16, activation='relu'),\n",
        "  tf.keras.layers.Dense(K)\n",
        "])\n",
        "  "
      ],
      "metadata": {
        "id": "AIgkQzmw7QsC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# CNN and LSTM train\n",
        "history = {}\n",
        "y_preds = []\n",
        "val_losses = []\n",
        "models = [model_CNN]\n",
        "names = ['CNN']\n",
        "\n",
        "for idx, name in enumerate(names):\n",
        "  # instantiate call backs\n",
        "  check_point = ModelCheckpoint('best_model_'+name+'.h5', monitor='val_loss', save_best_only=True)\n",
        "  early_stopping = EarlyStopping(monitor='val_loss', patience=10)\n",
        "\n",
        "  # Compile Model\n",
        "  model = compile(models[idx])\n",
        "\n",
        "  # Fit Model\n",
        "  history[name] = model.fit(NTD_x_train, NT_y_train, epochs=30, \n",
        "                      validation_data=(NTD_x_val, NT_y_val),\n",
        "                      callbacks=[check_point, early_stopping],\n",
        "                      verbose=2)\n",
        "  \n",
        "  # Get best model from current model\n",
        "  best_model = tf.keras.models.load_model('best_model_'+name+'.h5')\n",
        "\n",
        "  # Make predictions with best model \n",
        "  y_pred = best_model.predict(NTD_x_val)\n",
        "  y_preds.append(y_pred)\n",
        "\n",
        "  # Evaluate with best model\n",
        "  val_loss = best_model.evaluate(NTD_x_val, NT_y_val)\n",
        "  val_losses.append(val_loss)\n",
        "\n",
        "  tf.keras.backend.clear_session()\n",
        "\n",
        "# Plot metric\n",
        "plotter = tfdocs.plots.HistoryPlotter(metric = 'loss', smoothing_std=10)\n",
        "plotter.plot(history)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 990
        },
        "outputId": "acdeada5-509b-4bcc-e082-b7220b0c2fb9",
        "id": "4yzWAMVaA2Qu"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/30\n",
            "1296/1296 - 10s - loss: 0.0248 - val_loss: 0.0205\n",
            "Epoch 2/30\n",
            "1296/1296 - 5s - loss: 0.0197 - val_loss: 0.0201\n",
            "Epoch 3/30\n",
            "1296/1296 - 5s - loss: 0.0188 - val_loss: 0.0209\n",
            "Epoch 4/30\n",
            "1296/1296 - 5s - loss: 0.0184 - val_loss: 0.0195\n",
            "Epoch 5/30\n",
            "1296/1296 - 5s - loss: 0.0181 - val_loss: 0.0195\n",
            "Epoch 6/30\n",
            "1296/1296 - 5s - loss: 0.0177 - val_loss: 0.0199\n",
            "Epoch 7/30\n",
            "1296/1296 - 5s - loss: 0.0175 - val_loss: 0.0201\n",
            "Epoch 8/30\n",
            "1296/1296 - 5s - loss: 0.0173 - val_loss: 0.0196\n",
            "Epoch 9/30\n",
            "1296/1296 - 5s - loss: 0.0170 - val_loss: 0.0209\n",
            "Epoch 10/30\n",
            "1296/1296 - 5s - loss: 0.0168 - val_loss: 0.0206\n",
            "Epoch 11/30\n",
            "1296/1296 - 5s - loss: 0.0166 - val_loss: 0.0206\n",
            "Epoch 12/30\n",
            "1296/1296 - 5s - loss: 0.0163 - val_loss: 0.0210\n",
            "Epoch 13/30\n",
            "1296/1296 - 5s - loss: 0.0160 - val_loss: 0.0207\n",
            "Epoch 14/30\n",
            "1296/1296 - 5s - loss: 0.0157 - val_loss: 0.0211\n",
            "Epoch 15/30\n",
            "1296/1296 - 5s - loss: 0.0157 - val_loss: 0.0221\n",
            "385/385 [==============================] - 1s 2ms/step - loss: 0.0195\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Check R2-score\n",
        "r2_score(NT_y_val, y_pred)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "84351ab9-7b10-4234-952f-d524698d2510",
        "id": "fCZRio2VT_lq"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.7685044265852198"
            ]
          },
          "metadata": {},
          "execution_count": 68
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "This model ordinarily results in a better improvement than ANN and  CNN when T = 5. So let's finetue this model further."
      ],
      "metadata": {
        "id": "3_2RpJ90DndB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# CNN Model - 1D Convnet\n",
        "model_CNN = tf.keras.Sequential([\n",
        "  tf.keras.layers.Conv1D(32, 3, activation='relu', padding='same', input_shape=(T,D), kernel_initializer='he_uniform'),\n",
        "  tf.keras.layers.BatchNormalization(),\n",
        "  tf.keras.layers.MaxPooling1D(),\n",
        "  tf.keras.layers.Dropout(0.4),\n",
        "\n",
        "  tf.keras.layers.Conv1D(64, 3, activation='relu', padding='same', kernel_initializer='he_uniform'),\n",
        "  tf.keras.layers.BatchNormalization(),\n",
        "  tf.keras.layers.MaxPooling1D(),\n",
        "  tf.keras.layers.Dropout(0.4),\n",
        "\n",
        "  # tf.keras.layers.Conv1D(64, 3, activation='relu', padding='same', kernel_initializer='he_uniform'),\n",
        "  # tf.keras.layers.BatchNormalization(),\n",
        "  # tf.keras.layers.MaxPooling1D(),\n",
        "  # tf.keras.layers.Dropout(0.2),\n",
        "\n",
        "  tf.keras.layers.Flatten(),  \n",
        "  tf.keras.layers.Dense(16, activation='relu'),\n",
        "  tf.keras.layers.BatchNormalization(),\n",
        "  tf.keras.layers.Dropout(0.2),\n",
        "\n",
        "  # output layer\n",
        "  tf.keras.layers.Dense(K)\n",
        "])\n",
        "  "
      ],
      "metadata": {
        "id": "6GXqKy-sEHcM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# CNN and LSTM train\n",
        "history = {}\n",
        "y_preds = []\n",
        "val_losses = []\n",
        "models = [model_CNN]\n",
        "names = ['CNN']\n",
        "\n",
        "for idx, name in enumerate(names):\n",
        "  # instantiate call backs\n",
        "  check_point = ModelCheckpoint('best_model_'+name+'.h5', monitor='val_loss', save_best_only=True)\n",
        "  early_stopping = EarlyStopping(monitor='val_loss', patience=10)\n",
        "\n",
        "  # Compile Model\n",
        "  model = compile(models[idx])\n",
        "\n",
        "  # Fit Model\n",
        "  history[name] = model.fit(NTD_x_train, NT_y_train, epochs=30, \n",
        "                      validation_data=(NTD_x_val, NT_y_val),\n",
        "                      callbacks=[check_point, early_stopping],\n",
        "                      verbose=2)\n",
        "  \n",
        "  # Get best model from current model\n",
        "  best_model = tf.keras.models.load_model('best_model_'+name+'.h5')\n",
        "\n",
        "  # Make predictions with best model \n",
        "  y_pred = best_model.predict(NTD_x_val)\n",
        "  y_preds.append(y_pred)\n",
        "\n",
        "  # Evaluate with best model\n",
        "  val_loss = best_model.evaluate(NTD_x_val, NT_y_val)\n",
        "  val_losses.append(val_loss)\n",
        "\n",
        "  tf.keras.backend.clear_session()\n",
        "\n",
        "# Plot metric\n",
        "plotter = tfdocs.plots.HistoryPlotter(metric = 'loss', smoothing_std=10)\n",
        "plotter.plot(history)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "690decb3-3278-446e-ae08-0e1ea8a4d35d",
        "id": "CuzWQDAQEHcN"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/30\n",
            "1296/1296 - 13s - loss: 0.2111 - val_loss: 0.0367\n",
            "Epoch 2/30\n",
            "1296/1296 - 12s - loss: 0.0425 - val_loss: 0.0328\n",
            "Epoch 3/30\n",
            "1296/1296 - 12s - loss: 0.0342 - val_loss: 0.0251\n",
            "Epoch 4/30\n",
            "1296/1296 - 11s - loss: 0.0308 - val_loss: 0.0236\n",
            "Epoch 5/30\n",
            "1296/1296 - 13s - loss: 0.0289 - val_loss: 0.0225\n",
            "Epoch 6/30\n",
            "1296/1296 - 13s - loss: 0.0273 - val_loss: 0.0210\n",
            "Epoch 7/30\n",
            "1296/1296 - 12s - loss: 0.0264 - val_loss: 0.0212\n",
            "Epoch 8/30\n",
            "1296/1296 - 12s - loss: 0.0256 - val_loss: 0.0219\n",
            "Epoch 9/30\n",
            "1296/1296 - 12s - loss: 0.0252 - val_loss: 0.0208\n",
            "Epoch 10/30\n",
            "1296/1296 - 13s - loss: 0.0250 - val_loss: 0.0202\n",
            "Epoch 11/30\n",
            "1296/1296 - 13s - loss: 0.0244 - val_loss: 0.0197\n",
            "Epoch 12/30\n",
            "1296/1296 - 13s - loss: 0.0243 - val_loss: 0.0204\n",
            "Epoch 13/30\n",
            "1296/1296 - 13s - loss: 0.0240 - val_loss: 0.0195\n",
            "Epoch 14/30\n",
            "1296/1296 - 13s - loss: 0.0239 - val_loss: 0.0190\n",
            "Epoch 15/30\n",
            "1296/1296 - 12s - loss: 0.0241 - val_loss: 0.0202\n",
            "Epoch 16/30\n",
            "1296/1296 - 11s - loss: 0.0241 - val_loss: 0.0194\n",
            "Epoch 17/30\n",
            "1296/1296 - 12s - loss: 0.0237 - val_loss: 0.0190\n",
            "Epoch 18/30\n",
            "1296/1296 - 12s - loss: 0.0237 - val_loss: 0.0202\n",
            "Epoch 19/30\n",
            "1296/1296 - 12s - loss: 0.0237 - val_loss: 0.0195\n",
            "Epoch 20/30\n",
            "1296/1296 - 12s - loss: 0.0237 - val_loss: 0.0194\n",
            "Epoch 21/30\n",
            "1296/1296 - 12s - loss: 0.0236 - val_loss: 0.0195\n",
            "Epoch 22/30\n",
            "1296/1296 - 12s - loss: 0.0235 - val_loss: 0.0202\n",
            "Epoch 23/30\n",
            "1296/1296 - 12s - loss: 0.0234 - val_loss: 0.0196\n",
            "Epoch 24/30\n",
            "1296/1296 - 12s - loss: 0.0232 - val_loss: 0.0195\n",
            "385/385 [==============================] - 1s 3ms/step - loss: 0.0190\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Check R2-score\n",
        "r2_score(NT_y_val, y_pred)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b45cee87-aeaf-4ea7-c706-6f790d2a3cf3",
        "id": "_6hw4JO-EHcN"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.7741314861535076"
            ]
          },
          "metadata": {},
          "execution_count": 83
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Tune CNN Model"
      ],
      "metadata": {
        "id": "C9INK1gcML9c"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a tf Dataset for numpy array and batch\n",
        "BATCH_SIZE = 64\n",
        "train_dataset = tf.data.Dataset.from_tensor_slices((NTD_x_train,NT_y_train))\n",
        "val_dataset = tf.data.Dataset.from_tensor_slices((NTD_x_val,NT_y_val))"
      ],
      "metadata": {
        "id": "_d409Q95PYrZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# CNN Model - 1D Convnet\n",
        "def model_builder(hp):\n",
        "  model_CNN = tf.keras.Sequential([\n",
        "    tf.keras.layers.Conv1D(filters=(hp.Choice('filters1', values=[16,32,64,96,128])), kernel_size=3, activation='relu', padding='same', \n",
        "                           input_shape=(T,D,), kernel_initializer='he_uniform'),\n",
        "    # tf.keras.layers.BatchNormalization(),\n",
        "    tf.keras.layers.MaxPooling1D(),\n",
        "    tf.keras.layers.Dropout(hp.Choice('drop_rate1', values=[0.00 , 0.2 , 0.4 , 0.6, 0.8])),\n",
        "\n",
        "    tf.keras.layers.Conv1D(filters=(hp.Choice('filters2', values=[16,32,64,96,128])), kernel_size=3, activation='relu', padding='same', \n",
        "                           kernel_initializer='he_uniform'),\n",
        "    # tf.keras.layers.BatchNormalization(),\n",
        "    tf.keras.layers.MaxPooling1D(),\n",
        "    tf.keras.layers.Dropout(hp.Choice('drop_rate2', values=[0.00 , 0.2 , 0.4 , 0.6, 0.8])),\n",
        "\n",
        "    # tf.keras.layers.Conv1D(64, 3, activation='relu', padding='same', kernel_initializer='he_uniform'),\n",
        "    # tf.keras.layers.BatchNormalization(),\n",
        "    # tf.keras.layers.MaxPooling1D(),\n",
        "    # tf.keras.layers.Dropout(0.2),\n",
        "\n",
        "    tf.keras.layers.Flatten(),  \n",
        "    tf.keras.layers.Dense(units=(hp.Choice('units1', values=[16,32,64,96,128])), activation='relu'),\n",
        "    # tf.keras.layers.BatchNormalization(),\n",
        "    tf.keras.layers.Dropout(hp.Choice('drop_rate2', values=[0.00 , 0.2 , 0.4 , 0.6, 0.8])),\n",
        "\n",
        "    # output layer\n",
        "    tf.keras.layers.Dense(K)\n",
        "  ])\n",
        "\n",
        "  model.compile(optimizer=keras.optimizers.Adam(learning_rate=0.01),\n",
        "              loss='mse')\n",
        "\n",
        "  return model\n",
        "    "
      ],
      "metadata": {
        "id": "aa2A21XUMOeV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Use the hyperband tuner\n",
        "tuner_CNN = kt.Hyperband(model_builder,\n",
        "                    objective='val_loss',\n",
        "                    max_epochs=100,\n",
        "                    factor=3,\n",
        "                    directory='CNN',\n",
        "                    project_name='NASA_HI'\n",
        "                    )\n",
        "tuner_CNN.search_space_summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e7e4c21a-c542-4799-aa7f-4c4fd732a18a",
        "id": "PvpTarCOMW8L"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "INFO:tensorflow:Reloading Tuner from CNN\\NASA_HI\\tuner0.json\n",
            "Search space summary\n",
            "Default search space size: 5\n",
            "filters1 (Choice)\n",
            "{'default': 16, 'conditions': [], 'values': [16, 32, 64, 96, 128], 'ordered': True}\n",
            "drop_rate1 (Choice)\n",
            "{'default': 0.0, 'conditions': [], 'values': [0.0, 0.2, 0.4, 0.6, 0.8], 'ordered': True}\n",
            "filters2 (Choice)\n",
            "{'default': 16, 'conditions': [], 'values': [16, 32, 64, 96, 128], 'ordered': True}\n",
            "drop_rate2 (Choice)\n",
            "{'default': 0.0, 'conditions': [], 'values': [0.0, 0.2, 0.4, 0.6, 0.8], 'ordered': True}\n",
            "units1 (Choice)\n",
            "{'default': 16, 'conditions': [], 'values': [16, 32, 64, 96, 128], 'ordered': True}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Instantiate callbacks\n",
        "early_stopping = EarlyStopping(monitor='val_loss', patience=50)\n",
        "\n",
        "# Search - Takes in the same hyperparameters as fit\n",
        "tuner_CNN.search(NTD_x_train, NT_y_train, epochs=100, validation_data=(NTD_x_val, NT_y_val),\n",
        "                 callbacks=[early_stopping] )"
      ],
      "metadata": {
        "id": "_Vr0g3FCMW8L"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Shows the 10 best trials\n",
        "tuner_CNN.results_summary()"
      ],
      "metadata": {
        "id": "9Ubzt24QMW8L"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "best_hps = tuner_CNN.get_best_hyperparameters(num_trials = 1)[0]"
      ],
      "metadata": {
        "id": "boY5F8svMW8L"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "best_hps['reg_rate2']"
      ],
      "metadata": {
        "id": "EeQh8teUMW8L"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model_ANN = tuner_CNN.hypermodel.build(best_hps)\n",
        "# Retrain the model\n",
        "history =  model_CNN.fit(train_dataset, epochs=100, validation_data=val_dataset, callbacks=[early_stopping])"
      ],
      "metadata": {
        "id": "SKqbyS3CMW8L"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Compile, fit and plot\n",
        "# history = compile_and_fit(model, optimizer=None, max_epochs=70)\n",
        "plot_loss_accuracy(filename='CNN + Orig_data')\n"
      ],
      "metadata": {
        "id": "NoVAx39KMW8M"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Make predictions with best model \n",
        "y_pred = model_CNN.predict(val_dataset)\n",
        "\n",
        "# Check R2-score on validation set\n",
        "r2_score(y_val, y_pred)"
      ],
      "metadata": {
        "id": "UTRWiUtjMW8M"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Comments:\n",
        "\n",
        "\n",
        "*   Note: the keras tuner took about 3 hrs to train, this is a very long time but it was done to be able to see the best result we can get from the CNN model with the 3d data for this dataset. This shows that more sophisticted models is required for this dataset.\n",
        "*   Keras tuner results are: [filters1, drop_rate1, filters2, drop_rate2, units1] = [16, 32, 64, 0.4, 0.4]"
      ],
      "metadata": {
        "id": "lwk8TLB5lZf6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Put Best Model Predictions in dataframe and save."
      ],
      "metadata": {
        "id": "GY1r57hnAArQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "best_model = tf.keras.models.load_model('/content/best_model_CNN.h5')"
      ],
      "metadata": {
        "id": "M2hWbLSc_e6I"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Make predictions with best model \n",
        "y_pred = best_model.predict(NTD_x_val)"
      ],
      "metadata": {
        "id": "367w1Tg5_mnC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4fa24d98-52ff-4d08-a98b-759d0758b39f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "385/385 [==============================] - 9s 2ms/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Check R2-score\n",
        "r2_score(NT_y_val, y_pred)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uLMrm2qu_rjq",
        "outputId": "345bf5e8-159f-4c9e-986f-7acec9adc847"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.7741304390759769"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "y_pred = best_model.predict(NTD_x_val)\n",
        "y_train_pred = best_model.predict(NTD_x_train)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hJdJSUvMAGCM",
        "outputId": "042f64a3-2658-49a8-f065-5fb7be3cc42c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "385/385 [==============================] - 1s 2ms/step\n",
            "1296/1296 [==============================] - 2s 2ms/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "HItrain_df = pd.read_csv('/content/HItrain-dfr')\n",
        "HItrain_df.head()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "id": "TEVied5jCeJ3",
        "outputId": "8f5e3daf-aafd-46b4-8a1b-cf282c5fda64"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "   Unit_id  Time    ori_HI  Maxcycle  RUL    new_HI  apprx_HI  apprx_HI_ANN  \\\n",
              "0        1     1  1.000000       149  148  0.582822  0.546977      0.631525   \n",
              "1        1     2  0.993243       149  147  0.582912  0.581504      0.724908   \n",
              "2        1     3  0.986486       149  146  0.582965  0.601732      0.767940   \n",
              "3        1     4  0.979730       149  145  0.583290  0.726264      0.847148   \n",
              "4        1     5  0.972973       149  144  0.582879  0.568990      0.711482   \n",
              "\n",
              "     HI_PCA  new_HI_PCA  \n",
              "0 -0.859024   -1.192820  \n",
              "1 -0.628524   -1.197747  \n",
              "2 -0.404679   -1.202504  \n",
              "3 -1.859147   -1.171129  \n",
              "4 -0.310075   -1.204507  "
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-6e622ceb-0dbb-4061-8d67-39bddc85cd7e\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Unit_id</th>\n",
              "      <th>Time</th>\n",
              "      <th>ori_HI</th>\n",
              "      <th>Maxcycle</th>\n",
              "      <th>RUL</th>\n",
              "      <th>new_HI</th>\n",
              "      <th>apprx_HI</th>\n",
              "      <th>apprx_HI_ANN</th>\n",
              "      <th>HI_PCA</th>\n",
              "      <th>new_HI_PCA</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "      <td>1.000000</td>\n",
              "      <td>149</td>\n",
              "      <td>148</td>\n",
              "      <td>0.582822</td>\n",
              "      <td>0.546977</td>\n",
              "      <td>0.631525</td>\n",
              "      <td>-0.859024</td>\n",
              "      <td>-1.192820</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>1</td>\n",
              "      <td>2</td>\n",
              "      <td>0.993243</td>\n",
              "      <td>149</td>\n",
              "      <td>147</td>\n",
              "      <td>0.582912</td>\n",
              "      <td>0.581504</td>\n",
              "      <td>0.724908</td>\n",
              "      <td>-0.628524</td>\n",
              "      <td>-1.197747</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>1</td>\n",
              "      <td>3</td>\n",
              "      <td>0.986486</td>\n",
              "      <td>149</td>\n",
              "      <td>146</td>\n",
              "      <td>0.582965</td>\n",
              "      <td>0.601732</td>\n",
              "      <td>0.767940</td>\n",
              "      <td>-0.404679</td>\n",
              "      <td>-1.202504</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>1</td>\n",
              "      <td>4</td>\n",
              "      <td>0.979730</td>\n",
              "      <td>149</td>\n",
              "      <td>145</td>\n",
              "      <td>0.583290</td>\n",
              "      <td>0.726264</td>\n",
              "      <td>0.847148</td>\n",
              "      <td>-1.859147</td>\n",
              "      <td>-1.171129</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>1</td>\n",
              "      <td>5</td>\n",
              "      <td>0.972973</td>\n",
              "      <td>149</td>\n",
              "      <td>144</td>\n",
              "      <td>0.582879</td>\n",
              "      <td>0.568990</td>\n",
              "      <td>0.711482</td>\n",
              "      <td>-0.310075</td>\n",
              "      <td>-1.204507</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-6e622ceb-0dbb-4061-8d67-39bddc85cd7e')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-6e622ceb-0dbb-4061-8d67-39bddc85cd7e button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-6e622ceb-0dbb-4061-8d67-39bddc85cd7e');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "HIval_df = pd.read_csv('/content/HIval-dfr')\n",
        "HIval_df.head()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "id": "E19aWe81EFvH",
        "outputId": "365573f2-d72a-4d90-dd33-b82f84bd7292"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "   Unit_id  Time    ori_HI  Maxcycle  RUL  apprx_HI  apprx_HI_ANN    HI_PCA  \\\n",
              "0      201     1  1.000000       191  190  0.933014      0.898250 -3.938672   \n",
              "1      201     2  0.994737       191  189  0.763932      0.781614 -2.332807   \n",
              "2      201     3  0.989474       191  188  0.797754      0.796511 -2.512478   \n",
              "3      201     4  0.984211       191  187  0.739501      0.775219 -2.180602   \n",
              "4      201     5  0.978947       191  186  0.817956      0.820120 -3.277371   \n",
              "\n",
              "   new_HI_PCA  \n",
              "0   -1.124376  \n",
              "1   -1.160676  \n",
              "2   -1.156681  \n",
              "3   -1.164047  \n",
              "4   -1.139486  "
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-51fc6379-3575-4ba7-b51e-790eb54ed394\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Unit_id</th>\n",
              "      <th>Time</th>\n",
              "      <th>ori_HI</th>\n",
              "      <th>Maxcycle</th>\n",
              "      <th>RUL</th>\n",
              "      <th>apprx_HI</th>\n",
              "      <th>apprx_HI_ANN</th>\n",
              "      <th>HI_PCA</th>\n",
              "      <th>new_HI_PCA</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>201</td>\n",
              "      <td>1</td>\n",
              "      <td>1.000000</td>\n",
              "      <td>191</td>\n",
              "      <td>190</td>\n",
              "      <td>0.933014</td>\n",
              "      <td>0.898250</td>\n",
              "      <td>-3.938672</td>\n",
              "      <td>-1.124376</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>201</td>\n",
              "      <td>2</td>\n",
              "      <td>0.994737</td>\n",
              "      <td>191</td>\n",
              "      <td>189</td>\n",
              "      <td>0.763932</td>\n",
              "      <td>0.781614</td>\n",
              "      <td>-2.332807</td>\n",
              "      <td>-1.160676</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>201</td>\n",
              "      <td>3</td>\n",
              "      <td>0.989474</td>\n",
              "      <td>191</td>\n",
              "      <td>188</td>\n",
              "      <td>0.797754</td>\n",
              "      <td>0.796511</td>\n",
              "      <td>-2.512478</td>\n",
              "      <td>-1.156681</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>201</td>\n",
              "      <td>4</td>\n",
              "      <td>0.984211</td>\n",
              "      <td>191</td>\n",
              "      <td>187</td>\n",
              "      <td>0.739501</td>\n",
              "      <td>0.775219</td>\n",
              "      <td>-2.180602</td>\n",
              "      <td>-1.164047</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>201</td>\n",
              "      <td>5</td>\n",
              "      <td>0.978947</td>\n",
              "      <td>191</td>\n",
              "      <td>186</td>\n",
              "      <td>0.817956</td>\n",
              "      <td>0.820120</td>\n",
              "      <td>-3.277371</td>\n",
              "      <td>-1.139486</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-51fc6379-3575-4ba7-b51e-790eb54ed394')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-51fc6379-3575-4ba7-b51e-790eb54ed394 button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-51fc6379-3575-4ba7-b51e-790eb54ed394');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot(y_pred.flatten()[:1000]);"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 430
        },
        "id": "O-glNrLbEIjh",
        "outputId": "3adc8007-f3a0-43cd-95a5-6f8b5d3de997"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "y_train_pred = y_train_pred.flatten()\n",
        "y_pred = y_pred.flatten()"
      ],
      "metadata": {
        "id": "V88gJGGKFSBB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "ze = np.zeros(4,)\n",
        "y_train_pred = np.concatenate((ze,y_train_pred), axis=0)\n",
        "y_train_pred.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PD8iiUjeGFO8",
        "outputId": "3958e863-61ea-4450-ef4f-056462965a9c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(41456,)"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "ze = np.zeros(4,)\n",
        "y_pred = np.concatenate((ze,y_pred), axis=0)\n",
        "y_pred.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3tWT93MzGk_X",
        "outputId": "de27407f-bddb-4af9-8c7b-3382ce08aef7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(12303,)"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "HItrain_df['apprx_HI_CNN'] = y_train_pred\n",
        "HIval_df['apprx_HI_CNN'] = y_pred"
      ],
      "metadata": {
        "id": "nXd1KNZrExv2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "HItrain_df.to_csv('HItrain_df')\n",
        "HIval_df.to_csv('HIval_df')"
      ],
      "metadata": {
        "id": "Fy4Z6eHUHFj9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Comment: With the CNN, time window of 5 we were able to reduce the error from 0.23 to 0.0190. I almost missed it,and the rscore from 0.72 to 0.77. But we still need more, we need a rscore of around 90% so more sophisticated models will be used next."
      ],
      "metadata": {
        "id": "cTT2wagG_w3_"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "XdjaVdXIxaKz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Attention Network."
      ],
      "metadata": {
        "id": "U7XgG9tEpDTn"
      }
    }
  ]
}