les_rnn_cnn_updated_final.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "63323b92",
   "metadata": {},
   "source": [
    "# INFO 6106 - Neural Modeling: Final Project\n",
    "# Lake Snow Effect using RNN and CNN models\n",
    "**Submitted by:**\n",
    "- Aditi Krishna\n",
    "- Abhishek Shankar"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "544a13a7",
   "metadata": {},
   "source": [
    "Importing libraries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0ad78f58",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' \n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import pickle\n",
    "import ast\n",
    "from tqdm.notebook import tqdm\n",
    "\n",
    "# Plotting libraries\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.cm as cm\n",
    "import seaborn as sns\n",
    "%matplotlib inline\n",
    "\n",
    "# Tensorflow\n",
    "from __future__ import print_function\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras.models import Sequential, Model\n",
    "from tensorflow.keras import models, layers, optimizers, losses, metrics, regularizers\n",
    "from tensorflow.keras.datasets import mnist\n",
    "from tensorflow.keras.utils import to_categorical\n",
    "from keras.optimizers import Adam, SGD\n",
    "# tf.config.run_functions_eagerly(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8a80936",
   "metadata": {},
   "source": [
    "We read the saved data from the last notebook, where we cleaned the dataset based on different conditions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ea2819cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "filtered_les_new = pd.read_csv('updated.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66beaf14",
   "metadata": {},
   "source": [
    "#### Separating the data into X and y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b89eac20",
   "metadata": {},
   "outputs": [],
   "source": [
    "X_les = filtered_les_new.loc[:, filtered_les_new.columns != 'LES_Snowfall']\n",
    "y_les = filtered_les_new['LES_Snowfall']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c587e0b",
   "metadata": {},
   "source": [
    "#### Scaling the data\n",
    "Using `MinMaxScaler` to scale the features and then recreating a dataframe with same column names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "eba1c427",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<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>RH_pct</th>\n",
       "      <th>Wind_Spd_mph</th>\n",
       "      <th>Wind_Direction_deg</th>\n",
       "      <th>Low_Cloud_Ht_ft</th>\n",
       "      <th>Med_Cloud_Ht_ft</th>\n",
       "      <th>High_Cloud_Ht_ft</th>\n",
       "      <th>Visibility_mi</th>\n",
       "      <th>Atm_Press_hPa</th>\n",
       "      <th>Sea_Lev_Press_hPa</th>\n",
       "      <th>Altimeter_hPa</th>\n",
       "      <th>idx</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.49</td>\n",
       "      <td>0.294118</td>\n",
       "      <td>0.750000</td>\n",
       "      <td>0.128571</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.976249</td>\n",
       "      <td>0.975278</td>\n",
       "      <td>0.976302</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.47</td>\n",
       "      <td>0.088235</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.976249</td>\n",
       "      <td>0.975182</td>\n",
       "      <td>0.976302</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.55</td>\n",
       "      <td>0.176471</td>\n",
       "      <td>0.111111</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.976249</td>\n",
       "      <td>0.975278</td>\n",
       "      <td>0.976302</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.71</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.976249</td>\n",
       "      <td>0.975278</td>\n",
       "      <td>0.976302</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.82</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.285714</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.976249</td>\n",
       "      <td>0.975374</td>\n",
       "      <td>0.976302</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   RH_pct  Wind_Spd_mph  Wind_Direction_deg  Low_Cloud_Ht_ft  Med_Cloud_Ht_ft   \n",
       "0    0.49      0.294118            0.750000         0.128571              0.0  \\\n",
       "1    0.47      0.088235            0.000000         0.000000              0.0   \n",
       "2    0.55      0.176471            0.111111         0.000000              0.0   \n",
       "3    0.71      0.000000            0.000000         0.000000              0.0   \n",
       "4    0.82      0.000000            0.000000         0.285714              0.0   \n",
       "\n",
       "   High_Cloud_Ht_ft  Visibility_mi  Atm_Press_hPa  Sea_Lev_Press_hPa   \n",
       "0               0.0            1.0       0.976249           0.975278  \\\n",
       "1               0.0            1.0       0.976249           0.975182   \n",
       "2               0.0            1.0       0.976249           0.975278   \n",
       "3               0.0            1.0       0.976249           0.975278   \n",
       "4               0.0            1.0       0.976249           0.975374   \n",
       "\n",
       "   Altimeter_hPa  idx  \n",
       "0       0.976302    0  \n",
       "1       0.976302    1  \n",
       "2       0.976302    2  \n",
       "3       0.976302    3  \n",
       "4       0.976302    4  "
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Fitting MinMaxScaler()\n",
    "scaler = MinMaxScaler()\n",
    "idxes = X_les['idx']\n",
    "\n",
    "# Transform data and put it together with the same indices\n",
    "scaled = scaler.fit_transform(X_les)\n",
    "X_les = pd.DataFrame(scaled, columns = X_les.columns.tolist())\n",
    "X_les['idx'] = idxes\n",
    "# X_les.drop(['Unnamed: 0'], axis=1, inplace=True)\n",
    "X_les.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81e2260a",
   "metadata": {},
   "source": [
    "# Data Preparation for RNN\n",
    "### Function to prepare X & y based on the n_past hours of observations and predicting n_future hours into the future\n",
    "- We assume the data to be continous\n",
    "- The idea behind this data preparation function is to introduce a sliding window over the time series data\n",
    "- We convert the time series dataset to be fit for a supervised learning problem\n",
    "    - For example, if it is snowing at 2pm in the day then it does seem highly likely that it will snow at 3pm as well \n",
    "- In the function below we add the following parameters:\n",
    "    - **n_past** : the number of hours from the past observations to consider for prediction\n",
    "    - **n_future** :the number of hours into the future that we aim to predict\n",
    "- `Preparing X with sliding windows`\n",
    "    - The above operation takes 10 features for every hour of observation\n",
    "    - After running the function, the number of observations for n_past hours gets stacked together to form a 2-D matrix, i.e., of shape $(nPast, 10)$\n",
    "    - We now get 2-D matrices for the number of sliding windows possible for the set of given observations (say, k)\n",
    "    - These 2-D matrices are stacked together to form a *tensor* X_train of shape $(k, nPast, 10)$\n",
    "- `Preparing y with sliding windows`\n",
    "    - We *assume*, that if at any hour **within** the window of now until the **n_future** hour, if the weather is that of snowing (LES_snowfall == 1), then it will snow and y will become 1, else it will be 0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02410098",
   "metadata": {},
   "source": [
    "## Predicting 5 days (5 x 7 hours) in advance based on 3 day (3 x 7 hours) of historical data/observation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d278822b",
   "metadata": {},
   "outputs": [],
   "source": [
    "n_past = 35\n",
    "n_future = 21\n",
    "\n",
    "def data_prep(X_les, y_les, n_past = n_past, n_future = n_future):\n",
    "    X, y = list(), list()\n",
    "    for i in range(n_past, len(X_les) - n_future): \n",
    "        '''\n",
    "        1. Sliding window with 1 hour of past data and predicting 72 hours into the future\n",
    "        (n_past = 1, n_future = 72)\n",
    "        ==> X_les[ 1-1 : 1 ] = X_les[0 : 1]\n",
    "        ==> X_les[ 2-1: 2 ] = X_les[1 : 2]\n",
    "        ==> X_les[ 3-1: 3 ] = X_les[2 : 3] ...\n",
    "        \n",
    "        1. Sliding window with 24 hours of past data and predicting 72 hours into the future\n",
    "        (n_past = 24, n_future = 72)\n",
    "        ==> X_les[ 24-24 : 24 ] = X_les[0 : 24]\n",
    "        ==> X_les[ 25-24: 25 ] = X_les[1 : 25]\n",
    "        ==> X_les[ 26-24: 26 ] = X_les[2 : 26] ...\n",
    "        '''\n",
    "        # Preparing X\n",
    "        # Converting each row of features from the dataframe into an array\n",
    "        observations = np.array(X_les[i - n_past : i]) # 2D matrix\n",
    "        # Stacking into list X \n",
    "        X.append(observations) # Tensor formed\n",
    "        \n",
    "        # Preparing y\n",
    "        # Check if sum of all 0s and 1s from ith hour to i + future_hours > 0, then snowfall = 1\n",
    "        within_sum = y_les[i : i + n_future].sum()\n",
    "        if within_sum > 0:\n",
    "            y.append(1)\n",
    "        else:\n",
    "            y.append(0)\n",
    "        \n",
    "    return np.array(X), np.array(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edff183f",
   "metadata": {},
   "source": [
    "## Rewriting converted images and resizing to 64 x 64 (RUN ONLY ONCE!!!!)\n",
    "The images are pretty large and take up a lot of memory and processing time for the network, so we decided to resize them into 64 x 64 pixels. Then, we convert the images into grayscale and save them for training. "
   ]
  },
  {
   "cell_type": "raw",
   "id": "55985495",
   "metadata": {},
   "source": [
    "from PIL import Image, ImageOps\n",
    "f = 'images'\n",
    "for file in tqdm(os.listdir(f)):\n",
    "    f_img = f+ \"/\"+file\n",
    "    img = Image.open(f_img)\n",
    "    img = img.resize((64,64))\n",
    "    img = ImageOps.grayscale(img)\n",
    "    img.save(f_img)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7bc97ed8",
   "metadata": {},
   "source": [
    "### Viewing the images\n",
    "Let's check the saved images. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f02e1f8d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(64, 64)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = plt.imread('images/0.png')\n",
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "9b3fbb1f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fd0837b7280>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "241b607d",
   "metadata": {},
   "source": [
    "## Load images to an array for training\n",
    "- We load the grayscale images in the form of array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "4b4e016a",
   "metadata": {},
   "outputs": [],
   "source": [
    "from skimage.transform import rescale, resize, downscale_local_mean\n",
    "import cv2\n",
    "\n",
    "def load_images(idxs_list):\n",
    "    final_images = []\n",
    "    for i, idxs in enumerate(idxs_list):\n",
    "        images = []\n",
    "        for idx in idxs:\n",
    "            # im shape -> (64, 64)\n",
    "            im = cv2.imread(f'images/{int(idx)}.png')\n",
    "            # Storing 1 channel, since the images are grayscale\n",
    "            images.append(im[:,:,0]) \n",
    "            # images shape -> (35, 64, 64) \n",
    "        final_images.append(np.array(images)[:,:,:,None]) # Since CNN needs a color channel, here = 1\n",
    "        # final_images shape -> (N, 35, 64, 64, 1) ==> 1 for grayscale\n",
    "    final_images = np.array(final_images)  \n",
    "    return final_images"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1d6f821",
   "metadata": {},
   "source": [
    "## Data formatting (RUN ONLY ONCE and save the tensors) !!!\n",
    "- Use the `data_prep` function to make sliding windows in our dataset\n",
    "- Split the data\n",
    "- Load and reshape the image data using the `load_images` function\n",
    "- Crop images to remove extra padding from the image\n",
    "- Save the transformed image and tabular data for training purpose"
   ]
  },
  {
   "cell_type": "raw",
   "id": "e1789283",
   "metadata": {},
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "from tensorflow.keras import regularizers\n",
    "\n",
    "# Split\n",
    "# Preparing data\n",
    "X, y = data_prep(X_les, y_les)\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25)\n",
    "\n",
    "# X_train -> (N, 35, 11) => 11 as idx is included\n",
    "# Get the last feature from all observations ('idx' feature)\n",
    "idxs = X_train[:,:,-1]\n",
    "# idxs -> (N, 35)\n",
    "idxs_val = X_test[:,:,-1]\n",
    "\n",
    "# Load images\n",
    "imgs_train = load_images(idxs)\n",
    "# imgs_train -> (N, 35, 64, 64, 1)\n",
    "imgs_test = load_images(idxs_val)\n",
    "\n",
    "# Crop the images to avoid zero padding across the lake (as not useful info)\n",
    "# NOTE: We already save the images such that the background is 0 padded instead of 1\n",
    "\n",
    "imgs_train = imgs_train[:,:,8:56,8:-8,:]\n",
    "# imgs_train -> (N, 35, 48, 48, 1)\n",
    "imgs_test = imgs_test[:,:,8:56,8:-8,:]\n",
    "\n",
    "# Saving data as .npy files\n",
    "np.save('images_test.npy', imgs_test)\n",
    "np.save('images_train.npy', imgs_train)\n",
    "\n",
    "# Removing the idx feature from the training data\n",
    "np.save('X_train.npy', X_train[:,:,:-1]) \n",
    "np.save('y_train.npy', y_train)\n",
    "\n",
    "# Removing the idx feature from the testing data\n",
    "np.save('X_test.npy', X_test[:,:,:-1])\n",
    "np.save('y_test.npy', y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54bf3e7e",
   "metadata": {},
   "source": [
    "## Read pre-formatted images and data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "cda3f995",
   "metadata": {},
   "outputs": [],
   "source": [
    "imgs_test = np.load('images_test.npy')\n",
    "imgs_train =  np.load('images_train.npy')\n",
    "\n",
    "X_train = np.load('X_train.npy')\n",
    "y_train = np.load('y_train.npy')\n",
    "\n",
    "X_test = np.load('X_test.npy')\n",
    "y_test = np.load('y_test.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "56fda3bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10458, 35, 10) (10458,) (10458, 35, 48, 48, 1) (3486, 35, 10) (3486,) (3486, 35, 48, 48, 1)\n"
     ]
    }
   ],
   "source": [
    "print(X_train.shape, y_train.shape, imgs_train.shape, X_test.shape, y_test.shape, imgs_test.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6c210e2",
   "metadata": {},
   "source": [
    "Let's plot the 0th image in 146th batch in grayscale:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "b2961ad7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fd074e476d0>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaAAAAGeCAYAAADSRtWEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAomElEQVR4nO3de2xd5Znv8d/aV9+3Y4fYhNiQGSiBMkmEIcGlZ4YJLhmmQtB4Ru05lSal6FSlTkSIjjpEmtJT1FGijgSUabiog4IqTRpORgocqgMdTmiMepqkiSFDgGkKnUzjNrHDzXfvi/d+zx8Ut4asZ+FL8trO9yNtiexnv2u9+91OnrXM++wncM45AQBwjsV8TwAAcH4iAQEAvCABAQC8IAEBALwgAQEAvCABAQC8IAEBALwgAQEAvCABAQC8SPiewIeVSiWdPHlS1dXVCoLA93QAAJPknNPg4KAWL16sWMy4z3Fnyfe+9z138cUXu3Q67VatWuUOHjz4scZ1d3c7STx48ODBY44/uru7zX/vz8od0JNPPqnNmzfr0Ucf1erVq/Xggw9q7dq1OnbsmBYtWmSOra6uliR9Wn+phJJnY3oAgLNoTAX9VP9n/N/zMIFzM/9lpKtXr9a1116r733ve5Le/7VaU1OTNm7cqHvuucccOzAwoEwmoxt0qxIBCQgA5poxV9A+Pa3+/n7V1NSEvm7GNyHk83l1dXWpra3t9yeJxdTW1qb9+/d/5PW5XE4DAwMTHgCA+W/GE9Dbb7+tYrGohoaGCc83NDSop6fnI6/funWrMpnM+KOpqWmmpwQAmIW8b8PesmWL+vv7xx/d3d2+pwQAOAdmfBPCwoULFY/H1dvbO+H53t5eNTY2fuT16XRa6XR6pqcBAJjlZjwBpVIptbS0aO/evbrtttskvb8JYe/evdqwYcNMnw447/xyR4v9gpJdP5eszJvxwnAqNBbEp7dnyeXDf+kSpErm2CBux0v5eHiwaK/JdM+dKhsLjcUjxsZjdrxYCl+zdLJgjh3J2hf3zX991IyfbWdlG/bmzZu1fv16XXPNNVq1apUefPBBDQ8P6/bbbz8bpwMAzEFnJQF9/vOf11tvvaV7771XPT09WrlypZ577rmPbEwAAJy/ztpX8WzYsIFfuQEAQnnfBQcAOD+RgAAAXpCAAABezLp2DMD5IHIrdc7YUpy1hwYRW44LCt9m/f4Lwq9LXTFiG3ZsGvHAHutcRHuWiPdtHjti67pidrw4Fr5msYht1rGI9y1jfCpRNIfmI+Indv+JfW7r2N2VobFSNitteTryGNwBAQC8IAEBALwgAQEAvCABAQC8IAEBALwgAQEAvCABAQC8oA4IOAv+Y+dK+wV9Rp2PZF4axkand90YFOy/9rFCeM2Li2rHEBEupaw6oKmvyfvjw48dRNT5uCCiHUPSfmMlo2VCdsSuuxqNqm8y5j4YlJtDY8np1SDFE0YNUtNwaKw4ElGs9sH5P9arAACYYSQgAIAXJCAAgBckIACAFyQgAIAXJCAAgBckIACAF9QB4bz1y+9fa78gor9MbCT8+i34rT3WKK+IVIqoSYnl7XNHdc0ppq1aHXusS0T09LHiETVEQd6+Xg6Mf81cRD1MVB+jqH5BJWtuUb2GovoBWUMjfhaKVl8pSanqnBmPGesyatQ3lXIfL7VwBwQA8IIEBADwggQEAPCCBAQA8IIEBADwggQEAPCCBAQA8II6IJy3ljxrX38VKuz6jVzGqAMqRdSVBBF1Jenw2FhZRH3SmBlWLG/HXTz8+CW7tY2KZXa8ZNQBBVF1VxHztuaWu8D+PIKsXS8Tz0bUVk29lEdj1XaNkjNqcVzELUSywl60pr961T7AFI25gk58jNdxBwQA8IIEBADwggQEAPCCBAQA8IIEBADwggQEAPCCbdiY09ynVoTGxqqS5tjqY332wd9+zwwHZeF7pV3W/pr7IGH/1XOV5aGxUrW917lYZe+VztXa61KoCL8ujdqanh6wtxSn+4uhsZKx/VuSClX29bK1LT4xErHe9i5spfrteLov/H0XU/b7ytfYJ09kw7dhL3zs5/bEZjnugAAAXpCAAABekIAAAF6QgAAAXpCAAABekIAAAF6QgAAAXlAHhFlt7MYWM57qHQ6NJU/adTyKqNVxxfCaFUkqvfWOfXxLRB2Q8oXQUOz02+bQWNKuA0o01Jvx7EVVobHUkH3NWn5qxIzH3zIKasbs9VYioljHaHFh1VVJUqnCXrP42wP2uQ2Fxlo7nrHPXagMX/ORz602x6b67d4co4siauV2HTDj08UdEADACxIQAMALEhAAwAsSEADACxIQAMALEhAAwAsSEADAC+qA4NXJ//EpM77opYi+OiWj/0zMvr5yLrzPiiSpaPe2CVJGDUUQcW0XUWPkstnwoPWeJQUR545F9DmqeKcv/NT9EfUwRi2OJLny8F5GbtR4z7L7L0mSSuGfp+s5bR87adfDuHjE52nUdSUjfs5i2WozXry4MjwY8SMs++OIHn+WcQcEAPCCBAQA8IIEBADwggQEAPCCBAQA8IIEBADwgm3YOOsSjQ2hsSX/t88cG+TC2xJIkk6Fb68tRWyjjtrOHLVV2hS3WwcESfuvXmDsn43aOevyeTs+OmrHjW3DsXTEVmhjm7UkBdbW+DG7dYCLaJ9hrWmQslseRG7Jj9jabm3jdu/22ef+zxNmvPxlMzwt9gbws487IACAFyQgAIAXJCAAgBckIACAFyQgAIAXJCAAgBckIACAF9QBYdrcp1bYLzjVFxoKfn0q4uB2rY4r2LUjpoh2DVGs2pKgpsoeHFEnpBGjVsdq1SDJRdUvRbzv2EWNobFSpsIcG+Ttz6OUCv8np5Cxa4ziI/axE28Phs8roias+B//acZxdkz6b+CLL76oW265RYsXL1YQBHrqqacmxJ1zuvfee3XhhReqvLxcbW1teuONN2ZqvgCAeWLSCWh4eFgrVqzQ9u3bzxj/zne+o4ceekiPPvqoDh48qMrKSq1du1bZiKs2AMD5ZdK/grv55pt18803nzHmnNODDz6ov/u7v9Ott94qSfrBD36ghoYGPfXUU/rCF74wvdkCAOaNGd2EcPz4cfX09KitrW38uUwmo9WrV2v//v1nHJPL5TQwMDDhAQCY/2Y0AfX09EiSGhomfvlkQ0PDeOzDtm7dqkwmM/5oamqaySkBAGYp79uwt2zZov7+/vFHd3e37ykBAM6BGU1AjY3vb9/s7e2d8Hxvb+947MPS6bRqamomPAAA89+M1gEtXbpUjY2N2rt3r1auXClJGhgY0MGDB3XnnXfO5KlwDg1+4TozXva23bMnEQ+/zgnKIvrLRPRpCTJGn5eI2g9XZveIiexFZMnZPXlKwyP2uYPwfkBRgoiePKqrNcMjl9WHxlzcntdonV3f9N4nw2Mubn/WyUH7Z6X5W68YB4/qogQfJp2AhoaG9Oabb47/+fjx4zpy5Ijq6urU3NysTZs26dvf/rYuu+wyLV26VN/4xje0ePFi3XbbbTM5bwDAHDfpBHT48GH9+Z//+fifN2/eLElav369nnjiCX3961/X8PCwvvKVr6ivr0+f/vSn9dxzz6msLOKqDABwXpl0ArrhhhvM9rVBEOi+++7TfffdN62JAQDmN++74AAA5ycSEADACxIQAMAL2jFAiT+6xIwv+KldHOwK9nZlZ7UWiNpuHIuIW1uto8ZGfEFuyZq3JJXCz+0itoBHtZlQwvirGdVOoaLcjOcuqjXjI4vCz12K+Bdj8GI7PlYV3ioilrXfV/P//Jl9cMw53AEBALwgAQEAvCABAQC8IAEBALwgAQEAvCABAQC8IAEBALygDug8Eb/isvBg36A51mVz9sGjalqsepmor8k3xkqSGw2v5QnidmsAVxizzx1VR2QNraq0X1Bfa4bzTQtCY31/ZLclGFlsz3us3F7zserwNQ8K9rFXXPMrM35yKBMay/zlm6ExzE/cAQEAvCABAQC8IAEBALwgAQEAvCABAQC8IAEBALwgAQEAvKAOaJ6IX7rUfoFR8+LGwnu0SJKKdtxFxM+mIKqfkCFWXma/IJU0w4VPNofGTq20e/IMN9v1TcW68B5L5dV23VYiEfF5Fey/9kv/+qgZtwxHxDN6a8rHxvzDHRAAwAsSEADACxIQAMALEhAAwAsSEADACxIQAMALEhAAwAvqgOaIXz68yowve3jAjAenTocHI/riRNb5RNUJWT1/SnZvmiA+jWukiH5AQX14zx1Jerf1QjP+zp+E1yAVau01DSrseCIZXidULNprksva9UvpsvAaI+Bc4g4IAOAFCQgA4AUJCADgBQkIAOAFCQgA4AUJCADgBduw54hLd+bNeGxoxIw7Y7tz5DZraxu1JCXtbb9ByW49YIpN/RopaFhoxt9d1WDG+//IPnfJ2CqtiC4RsYS9pnGjpUJ+1F7vy9a/ZJ8cmCW4AwIAeEECAgB4QQICAHhBAgIAeEECAgB4QQICAHhBAgIAeEEd0Cwy3L46NJY5fNIc60ayUz/xNGptJElRdT5WHVFEy4QoQcqoiYk4dtUJe83yVeVm3FmtIpxdCFQq2vF8ZfixUxV2TRgwV3AHBADwggQEAPCCBAQA8IIEBADwggQEAPCCBAQA8IIEBADwgjqgc+iNJ1rMePP/Cq+ncdmcffBCRG2I0Q8oUlS/oGkIgojGORFcvhB+7HfeM8faXXWkyt6UGY+NhdcZZevt91Wotq/98mPhs8vluW7E/MBPMgDACxIQAMALEhAAwAsSEADACxIQAMALEhAAwAu2YZ9DS39gx9On+qZ+8ETERzk2Fh4r2lu0g6hjR4mFb0kOysrMoWPNi8y41RIhV5+2j11ub5Uerbevz3ILwsfnFtotKoqVES0skuHxhgv77LHAHMEdEADACxIQAMALEhAAwAsSEADACxIQAMALEhAAwAsSEADAC+qAzqHEkN0yIciGx11US4RiRF2J0Y4hsiVC0v4xCVJ22wKlwlsLlBZUm0OLFXbTBBcPn3spZb+vWMSSRsaN0qr4aMSaOvvab+GV74bGMn/5pn1sYI6Y1B3Q1q1bde2116q6ulqLFi3SbbfdpmPHjk14TTabVUdHh+rr61VVVaX29nb19vbO6KQBAHPfpBJQZ2enOjo6dODAAT3//PMqFAq66aabNDw8PP6au+++W88884x2796tzs5OnTx5UuvWrZvxiQMA5rZJ/Qruueeem/DnJ554QosWLVJXV5f+9E//VP39/Xr88ce1c+dOrVmzRpK0Y8cOXXHFFTpw4ICuu+66mZs5AGBOm9YmhP7+fklSXV2dJKmrq0uFQkFtbW3jr1m2bJmam5u1f//+Mx4jl8tpYGBgwgMAMP9NOQGVSiVt2rRJ119/va666ipJUk9Pj1KplGpraye8tqGhQT09PWc8ztatW5XJZMYfTU1NU50SAGAOmXIC6ujo0Kuvvqpdu3ZNawJbtmxRf3//+KO7u3taxwMAzA1T2oa9YcMG/ehHP9KLL76oJUuWjD/f2NiofD6vvr6+CXdBvb29amxsPOOx0um00mn7a/MBAPPPpBKQc04bN27Unj17tG/fPi1dunRCvKWlRclkUnv37lV7e7sk6dixYzpx4oRaW1tnbtazVPwTf2y/YChnx/OFqcUkKR43w84ZdUBR/X6i4mm7DsiVh19g5OvKzbGBUb8kSYHRy6i8115vF1GqE8/aNUgqGesSUVs1UmG/L2p9cD6YVALq6OjQzp079fTTT6u6unr8/+tkMhmVl5crk8nojjvu0ObNm1VXV6eamhpt3LhRra2t7IADAEwwqQT0yCOPSJJuuOGGCc/v2LFDX/rSlyRJDzzwgGKxmNrb25XL5bR27Vo9/PDDMzJZAMD8MelfwUUpKyvT9u3btX379ilPCgAw//FlpAAAL0hAAAAvSEAAAC9IQAAAL+gHNElja1pCY/Hf9NmD33rPDLuS0YAmos5Hzu4HFMSNa42IOp+ofj+l2iozbvXsiY8aTXUkBVEbX4w6ofwCu8C5WG5ffxUq7HhyNPzc9d8583cfAvg97oAAAF6QgAAAXpCAAABekIAAAF6QgAAAXpCAAABesA37Q05v+JQZX3R4KDQWjEa0W0hEbKWOh293dtmsPTaqt4BlzN4KLdnbmUtlU/8xSgxEva+Ibdhj4VvX7c3jUj4os08d2Od2ER8nABt3QAAAL0hAAAAvSEAAAC9IQAAAL0hAAAAvSEAAAC9IQAAAL6gD+pDaN/JmPDYUHnfZiDqgCNOo5JGKRisHSQqMa42IVg5udNSMJ3r67PEV4fU2wYhdB+RG7bjVKiKoKTfHRsnV2Ndn2frwT+z0D1eYY5f+13+b0pyA+YQ7IACAFyQgAIAXJCAAgBckIACAFyQgAIAXJCAAgBckIACAF9QBfUi2zl6SslPhsSCVNMe6fGEqU3r/2MmIY0f29DHEIxrbRMzb9Q+a8cCoj3JR/X6qK81woSETGhu4xO73k6+xK6+yCyPifxz+vspT0/g8gPMEd0AAAC9IQAAAL0hAAAAvSEAAAC9IQAAAL0hAAAAv2Ib9IQOX2Dl5wb+Fty6I3AodEXcFuxWEObZot1QIrJ3WpYjrkNi0GkXIFYxt3DF7C3gQ8b5ydeHtGAYvtt/XyJKIzyttn7uyJrxVxEXrXrOPDYA7IACAHyQgAIAXJCAAgBckIACAFyQgAIAXJCAAgBckIACAF+ddHdCv72s14w0/t2tDgpHw2g9XLE5pTuOstgglu21BEES0NbDGR3RjiOLyU69fii2oNeOFRjs+vCh88sW0fe7EgP3GS2n7+iz4RXgrCADRuAMCAHhBAgIAeEECAgB4QQICAHhBAgIAeEECAgB4QQICAHhx3tUBZd6w45XH+8246x80gnb/mEhWX57pHtsSVb9k1SdJCi5qNOP9KxaGxt673D529kJ7bi4eHk++ax8786YZVmrIjleeGrVfAMDEHRAAwAsSEADACxIQAMALEhAAwAsSEADACxIQAMALEhAAwIt5Vwc0sm61Ga97+T37AG9HxC0RPXuiGTUvsWCaxw4X1C8w4++tvtCMn26x51asNN5XomCOTVTZ8YqKXPh5F9nXV+81pcy4K0WsuQs/vvtSizn0E7d32ccGzgPcAQEAvCABAQC8IAEBALwgAQEAvCABAQC8IAEBALyYk9uw839xbWis4qT9Ffmxkax98MDeemtutE6n7WNHKeTDY1FbvCO2abvm8K3Uv/lMnTl26OKIlghJu1VEbHTq1znFMvvcCaMdQ3nK3sIdi9nzThrHlqRcIRkaGxkoM8f+8vvhP8OS9In/fsiMA/PBpP5leOSRR7R8+XLV1NSopqZGra2tevbZZ8fj2WxWHR0dqq+vV1VVldrb29Xb2zvjkwYAzH2TSkBLlizRtm3b1NXVpcOHD2vNmjW69dZb9dprr0mS7r77bj3zzDPavXu3Ojs7dfLkSa1bt+6sTBwAMLdN6ldwt9xyy4Q///3f/70eeeQRHThwQEuWLNHjjz+unTt3as2aNZKkHTt26IorrtCBAwd03XXXzdysAQBz3pR/OV8sFrVr1y4NDw+rtbVVXV1dKhQKamtrG3/NsmXL1NzcrP3794ceJ5fLaWBgYMIDADD/TToBHT16VFVVVUqn0/rqV7+qPXv26Morr1RPT49SqZRqa2snvL6hoUE9PT2hx9u6dasymcz4o6mpadJvAgAw90w6AV1++eU6cuSIDh48qDvvvFPr16/X66+/PuUJbNmyRf39/eOP7u7uKR8LADB3THobdiqV0qWXXipJamlp0aFDh/Td735Xn//855XP59XX1zfhLqi3t1eNjY2hx0un00pPd/syAGDOmXYdUKlUUi6XU0tLi5LJpPbu3av29nZJ0rFjx3TixAm1trZOe6J/qFgWXvPi4vZN3fDlF5jxVJ9RiyMpNmbUjpTsupL4u0NmXKqY8rFzS+33dfrq8LqUoWb72C4RUYMUUQcUrw1vmVBebq+3VecjSfFY+NxyBfvHuzJtnzse2O/bufCfw4WL3zHHDubsVhDauyQ8duNv7LHAHDGpBLRlyxbdfPPNam5u1uDgoHbu3Kl9+/bpxz/+sTKZjO644w5t3rxZdXV1qqmp0caNG9Xa2soOOADAR0wqAZ0+fVp/8zd/o1OnTimTyWj58uX68Y9/rM985jOSpAceeECxWEzt7e3K5XJau3atHn744bMycQDA3DapBPT444+b8bKyMm3fvl3bt2+f1qQAAPMfX0YKAPCCBAQA8IIEBADwggQEAPBiTvYDKn/q5+HB65abY8t6Rsx4vC+iVidv9JgpRvTNKdj9aYJMTWjs3U9dZI59b5l9LZFbHH7uZHV4nY4kxYxaG0mqrbJ7MCWMvjuVSbsWJ50YM+NjpalfQ9Wk7N5QicCub8qX4qGxklEjJElLa+w1HyyEF2cPmiOBuYM7IACAFyQgAIAXJCAAgBckIACAFyQgAIAXJCAAgBdzchu2JT5gb60NBobNuMva4+WMLcmBvfVWsfBtu5JUqghvmTC60L5WyNfbW8CVCN9SXCzY86qssbdZlyft7eUL0vbWd0ssoiVChfG+orZRl8fteUepTIRvpS45+/PqL4R/1pJUkQjfnj70gr0l3635rRkHZgvugAAAXpCAAABekIAAAF6QgAAAXpCAAABekIAAAF6QgAAAXsy7OqDeT9eb8QteSpnx+Kl3zbgbM9oDlOyalSBu5/tiVfjcxirMoVIxogbJaA+QTNstDxJxu54mFbNrkPKlqf+YpWL23LJjyfCxcXvsdMWMOqNkRA1SJmnXm9Umw2un4hG1UTtOHjHjaxevNOPAucIdEADACxIQAMALEhAAwAsSEADACxIQAMALEhAAwAsSEADAi3lXB9T1Px8x423/7ctmPJ6we+MEMSNnWzVCklzJrg0JcuH1NEm7jZFiUa1tysLnlk5Nr15muGDXVqWdce6IWp2ovjplifA3HlVDFFVPE5Mdt+YeNdbqJSRJFbHwfkDvqtIce92RvzLjGb1pxoFzhTsgAIAXJCAAgBckIACAFyQgAIAXJCAAgBckIACAF/NuG3bUV83H9ZIZd5+83D5BIXzrbZCzWyIEEe0a4n1DobEFvygzxw4tsbdCO6MdQ8mISVIibrdbKE9G7QGfukREq4ezKRaxTdsSNe+47C35FfHwbdoXlvWbYwsL7OvKXjMKnDvcAQEAvCABAQC8IAEBALwgAQEAvCABAQC8IAEBALwgAQEAvJh3dUBv3n+dGU8O2TUvlb+1j1/12/D6jsSoXfsRM9otSJJVdhJVklLVbb+voSC8jmi43K4hGkrbX/8fr7LbHqTLwlsLXLbwbXNsddJuW5AIwutpYkZMkpIR8fJ4+LzfP374h2K1U5CkkuzPqzqWDY3lYklz7P/bf6UZv1QHzDhwrnAHBADwggQEAPCCBAQA8IIEBADwggQEAPCCBAQA8IIEBADwYt7VAf3qC4+a8Su3f82Mjy60j1+Khy9Zaihuji1U2Me2SkOKabtuJJ+Z+rEjRVymlIr2wYvF8AOUJexeQoWSvabDpfAapnzR/vGOqsWpStg1SFnj+P35cnNsJjVqxo8n60Nj6YheQ5dups4HcwN3QAAAL0hAAAAvSEAAAC9IQAAAL0hAAAAvSEAAAC9IQAAAL+ZdHdDaxSvNePHJITMei9mNdwbz4UtWHLD7tCji2IqHx4Ok3bsmXWHX01xS1xcaq06G9575OCoiannGXPh1zljJvgYaKqbNeM6oxSk5u85nIBveI+njCIx+QLmC/VdrJG3/rBSNdbnpol+YY0/Irp0CZgvugAAAXpCAAABekIAAAF6QgAAAXpCAAABekIAAAF7Mu23Yb95/nRkPuu3xpVJEa4Hq8K/Cj1XZ25Erq+3tzrXl4fG6shFzbEUib8ZjxpbhqO3KQ2P2VuhTI3brgexY+I9ZVJcIa95Rx47H7K3r5Un786ots1smWHLGvCR7C7dkby8/tJJt1pgfpnUHtG3bNgVBoE2bNo0/l81m1dHRofr6elVVVam9vV29vb3TnScAYJ6ZcgI6dOiQHnvsMS1fvnzC83fffbeeeeYZ7d69W52dnTp58qTWrVs37YkCAOaXKSWgoaEhffGLX9T3v/99LViwYPz5/v5+Pf7447r//vu1Zs0atbS0aMeOHfrZz36mAwfo0ggA+L0pJaCOjg599rOfVVtb24Tnu7q6VCgUJjy/bNkyNTc3a//+/Wc8Vi6X08DAwIQHAGD+m/QmhF27dumll17SoUOHPhLr6elRKpVSbW3thOcbGhrU09NzxuNt3bpV3/rWtyY7DQDAHDepO6Du7m7ddddd+ud//meVlU3vixw/sGXLFvX3948/ursjtqkBAOaFSSWgrq4unT59WldffbUSiYQSiYQ6Ozv10EMPKZFIqKGhQfl8Xn19fRPG9fb2qrGx8YzHTKfTqqmpmfAAAMx/k/oV3I033qijR49OeO7222/XsmXL9Ld/+7dqampSMpnU3r171d7eLkk6duyYTpw4odbW1pmbteFXX3jUjF+670tmfFGd/f+grJoZF1FPE1V3Up3KhcaqkuExyW55IEnp2FhoLJO0610uib1jxqNaJiQDo3Yqoh5mYMy+0y4Z7ztXsutl0rHweUlSXWrYjJfFwj/PYsTn8ebwBWY8ZXxeFDVgvphUAqqurtZVV1014bnKykrV19ePP3/HHXdo8+bNqqurU01NjTZu3KjW1lZdd51dIAoAOL/M+DchPPDAA4rFYmpvb1cul9PatWv18MMPz/RpAABz3LQT0L59+yb8uaysTNu3b9f27dune2gAwDzGl5ECALwgAQEAvCABAQC8IAEBALyYd/2A1i5eacYbn7PrfKJqdUYKyfBgRE3LgrTd06exfDA0tjjdZ45dmAgfGyXrjPckKS77fRUju/pM3YUp+xopW7LnbqmI27VV1TG7f1MyCK/ViUf8LHx70VEzHvVzDMwH3AEBALwgAQEAvCABAQC8IAEBALwgAQEAvCABAQC8mHfbsKNU/sV/mPFf7mgx459cejI0dlFFnzk2amtuwmhb0D9Wbo4dLNptC347Whsay0e0LahM5M34wtSQGbfaMYyUUubY09lqM26pS9nb3svj9vuqitimXXDh63Zopb2mP1CTGQfOB9wBAQC8IAEBALwgAQEAvCABAQC8IAEBALwgAQEAvCABAQC8OO/qgKJ84vYuM77ySHhNS65kL2dfocKMjxptEfqc3fKg5OxrifJ4eJuJ2uRoxFi7XiYdC29LINl1QLGI2qhF1Xabiep4eMsEq12CJF2SetuM94xlzHhf0fo8a82xALgDAgB4QgICAHhBAgIAeEECAgB4QQICAHhBAgIAeEECAgB4QR3QJP3whetDY2v/yxFz7KUVp814Jh7evyZr1AhJ0lBEP6B0LLwOKBO364AWJQbMeF3c7gdk9c0ZLqXNsVHqjXO/Vawxxw6U7DWLel8/XLbYjAOwcQcEAPCCBAQA8IIEBADwggQEAPCCBAQA8IIEBADwggQEAPCCOqBJunTzgdDYJ19/xxxbGcuZ8QuMepvBYrk5ti8Ir/ORpArj3PUJu97lgrjdk6cyou/OOyV77pZ4UDLjVn1U3qg/kqTHP7F0SnMCMDO4AwIAeEECAgB4QQICAHhBAgIAeEECAgB4QQICAHjBNuwZ9L+vrDfjX//VUTNubSmujmiZEBXvKdROKSZJF8X7zXhdrBgRN7Z5R2wBvzBRZcbXLl5pxgHMXtwBAQC8IAEBALwgAQEAvCABAQC8IAEBALwgAQEAvJh127Cdc5KkMRUk53kyM2x40N6unHNn73pgdMz+xmrLUMH+RuqKuB2fjsqEfewxZ38LOIBzb0zv/7384N/zMIGLesU59pvf/EZNTU2+pwEAmKbu7m4tWbIkND7rElCpVNLJkydVXV2tIAg0MDCgpqYmdXd3q6amxvf05gTWbPJYs8ljzSbvfFkz55wGBwe1ePFixWLhv9mZdb+Ci8ViZ8yYNTU18/oDOxtYs8ljzSaPNZu882HNMplM5GvYhAAA8IIEBADwYtYnoHQ6rW9+85tKp9O+pzJnsGaTx5pNHms2eazZRLNuEwIA4Pww6++AAADzEwkIAOAFCQgA4AUJCADgBQkIAODFrE9A27dv1yWXXKKysjKtXr1aP//5z31PadZ48cUXdcstt2jx4sUKgkBPPfXUhLhzTvfee68uvPBClZeXq62tTW+88Yafyc4CW7du1bXXXqvq6motWrRIt912m44dOzbhNdlsVh0dHaqvr1dVVZXa29vV29vracazwyOPPKLly5ePV++3trbq2WefHY+zZrZt27YpCAJt2rRp/DnW7H2zOgE9+eST2rx5s775zW/qpZde0ooVK7R27VqdPn3a99RmheHhYa1YsULbt28/Y/w73/mOHnroIT366KM6ePCgKisrtXbtWmWz2XM809mhs7NTHR0dOnDggJ5//nkVCgXddNNNGh4eHn/N3XffrWeeeUa7d+9WZ2enTp48qXXr1nmctX9LlizRtm3b1NXVpcOHD2vNmjW69dZb9dprr0lizSyHDh3SY489puXLl094njX7HTeLrVq1ynV0dIz/uVgsusWLF7utW7d6nNXsJMnt2bNn/M+lUsk1Nja6f/iHfxh/rq+vz6XTaffDH/7Qwwxnn9OnTztJrrOz0zn3/vokk0m3e/fu8df8+7//u5Pk9u/f72uas9KCBQvcP/3TP7FmhsHBQXfZZZe5559/3v3Zn/2Zu+uuu5xz/Jz9oVl7B5TP59XV1aW2trbx52KxmNra2rR//36PM5sbjh8/rp6engnrl8lktHr1atbvd/r7+yVJdXV1kqSuri4VCoUJa7Zs2TI1NzezZr9TLBa1a9cuDQ8Pq7W1lTUzdHR06LOf/eyEtZH4OftDs+7bsD/w9ttvq1gsqqGhYcLzDQ0N+sUvfuFpVnNHT0+PJJ1x/T6Inc9KpZI2bdqk66+/XldddZWk99cslUqptrZ2wmtZM+no0aNqbW1VNptVVVWV9uzZoyuvvFJHjhxhzc5g165deumll3To0KGPxPg5+71Zm4CAs6mjo0OvvvqqfvrTn/qeypxw+eWX68iRI+rv79e//Mu/aP369ers7PQ9rVmpu7tbd911l55//nmVlZX5ns6sNmt/Bbdw4ULF4/GP7Azp7e1VY2Ojp1nNHR+sEev3URs2bNCPfvQj/eQnP5nQe6qxsVH5fF59fX0TXs+aSalUSpdeeqlaWlq0detWrVixQt/97ndZszPo6urS6dOndfXVVyuRSCiRSKizs1MPPfSQEomEGhoaWLPfmbUJKJVKqaWlRXv37h1/rlQqae/evWptbfU4s7lh6dKlamxsnLB+AwMDOnjw4Hm7fs45bdiwQXv27NELL7ygpUuXToi3tLQomUxOWLNjx47pxIkT5+2ahSmVSsrlcqzZGdx44406evSojhw5Mv645ppr9MUvfnH8v1mz3/G9C8Kya9cul06n3RNPPOFef/1195WvfMXV1ta6np4e31ObFQYHB93LL7/sXn75ZSfJ3X///e7ll192v/71r51zzm3bts3V1ta6p59+2r3yyivu1ltvdUuXLnWjo6OeZ+7HnXfe6TKZjNu3b587derU+GNkZGT8NV/96lddc3Oze+GFF9zhw4dda2ura21t9Thr/+655x7X2dnpjh8/7l555RV3zz33uCAI3L/+678651izj+MPd8E5x5p9YFYnIOec+8d//EfX3NzsUqmUW7VqlTtw4IDvKc0aP/nJT5ykjzzWr1/vnHt/K/Y3vvEN19DQ4NLptLvxxhvdsWPH/E7aozOtlSS3Y8eO8deMjo66r33ta27BggWuoqLCfe5zn3OnTp3yN+lZ4Mtf/rK7+OKLXSqVchdccIG78cYbx5OPc6zZx/HhBMSavY9+QAAAL2bt/wMCAMxvJCAAgBckIACAFyQgAIAXJCAAgBckIACAFyQgAIAXJCAAgBckIACAFyQgAIAXJCAAgBf/Hwc4JZrUI+UhAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(imgs_test[146,0,:,:,0]) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb3446a3",
   "metadata": {},
   "source": [
    "Let's plot the 0th image in 21st batch in grayscale:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "eb788cd8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fd02f821580>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(imgs_train[21,0,:,:,0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5656f1d1",
   "metadata": {},
   "source": [
    "`Now we are ready to build our network!`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b982ce80",
   "metadata": {},
   "source": [
    "# 1. RNN using numerical meteorological data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5cdd14e",
   "metadata": {},
   "source": [
    "### Long Short-Term Memory (LSTM)\n",
    "**About the architecture:**\n",
    "- The numerical meteorological data has 10 features and we take 35 hours (5 x 7 hours) of *n_past* observations into account in order to predict 3 days (3 x 7 hours) into the future\n",
    "    - This gives the data a shape of `35 x 10`\n",
    "- We enable two LSTM layers in our architecture \n",
    "    - For the first layer, we have 35 recurring LSTM blocks with each block having a dense layer of 16 neurons\n",
    "    - The first layer has a `return_sequence = True`, which leads to each block returning an output resulting in 35 activations of size 16 \n",
    "    - These become the input for the second LSTM layer\n",
    "    - The second LSTM layer also has recurring 35 LSTM blocks of dense layers of 16 neurons, but this time the `return_sequence = False`, which means that *only* the final block gives an output of size 16\n",
    "    - The final block has all the information that is necessary due to the forward propagation of information in LSTM through time\n",
    "    - The final block is connected to a dense layer of one neuron, which returns a value between 0 and 1 (due to the sigmoid function)\n",
    "- We use the `Adam` optimizer with a `learning_rate` of 0.01 and a `Binary Cross Entropy` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "32d8bc0b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_1 (InputLayer)        [(None, 35, 10)]          0         \n",
      "                                                                 \n",
      " lstm (LSTM)                 (None, 35, 16)            1728      \n",
      "                                                                 \n",
      " lstm_1 (LSTM)               (None, 16)                2112      \n",
      "                                                                 \n",
      " dense (Dense)               (None, 1)                 17        \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 3,857\n",
      "Trainable params: 3,857\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "RNN = layers.LSTM\n",
    "data_shape = (35, 10)\n",
    "data = layers.Input(shape= data_shape)\n",
    "\n",
    "hidden_size = 16 # output shape of 1st LSTM block\n",
    "\n",
    "# Define layers in architecture\n",
    "lstm1 = RNN(hidden_size, input_shape=(35, data_shape[1]), return_sequences= True)(data)\n",
    "# Using second LSTM block on top of 1st LSTM block\n",
    "lstm2 = RNN(hidden_size, input_shape=(35, hidden_size), return_sequences= False)(lstm1)\n",
    "# Connecting output of 2nd LSTM block with a dense layer \n",
    "# Output dense layer with 1 neuron, since we have only two possible outputs - 0/1\n",
    "out = layers.Dense(1, activation='sigmoid')(lstm2)\n",
    "\n",
    "# Optimizer\n",
    "optim = Adam(learning_rate=0.01)\n",
    "model = Model(data, out)  \n",
    "\n",
    "# Compile and build model\n",
    "model.compile(loss='binary_crossentropy',\n",
    "              optimizer = optim,\n",
    "              metrics=['accuracy'])\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6504d3c",
   "metadata": {},
   "source": [
    "Check shape of `X_test`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "802e6d59",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3486, 35, 10)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_test.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4d4d0ee",
   "metadata": {},
   "source": [
    "## Training the LSTM model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "341dd5f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 0\n",
      "105/105 [==============================] - 3s 10ms/step - loss: 0.4718 - accuracy: 0.7939 - val_loss: 0.5048 - val_accuracy: 0.7963\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 1\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.4535 - accuracy: 0.7940 - val_loss: 0.4530 - val_accuracy: 0.7963\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 2\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.4499 - accuracy: 0.7977 - val_loss: 0.4394 - val_accuracy: 0.7969\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 3\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.4419 - accuracy: 0.7981 - val_loss: 0.4367 - val_accuracy: 0.8046\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as lstm_cell_layer_call_fn, lstm_cell_layer_call_and_return_conditional_losses, lstm_cell_1_layer_call_fn, lstm_cell_1_layer_call_and_return_conditional_losses while saving (showing 4 of 4). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 4\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.4389 - accuracy: 0.7993 - val_loss: 0.4271 - val_accuracy: 0.8150\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as lstm_cell_layer_call_fn, lstm_cell_layer_call_and_return_conditional_losses, lstm_cell_1_layer_call_fn, lstm_cell_1_layer_call_and_return_conditional_losses while saving (showing 4 of 4). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 5\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.4291 - accuracy: 0.8026 - val_loss: 0.4193 - val_accuracy: 0.8049\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 6\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.4260 - accuracy: 0.8037 - val_loss: 0.4205 - val_accuracy: 0.8161\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as lstm_cell_layer_call_fn, lstm_cell_layer_call_and_return_conditional_losses, lstm_cell_1_layer_call_fn, lstm_cell_1_layer_call_and_return_conditional_losses while saving (showing 4 of 4). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 7\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.4214 - accuracy: 0.8029 - val_loss: 0.4130 - val_accuracy: 0.7995\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 8\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.4253 - accuracy: 0.8042 - val_loss: 0.4106 - val_accuracy: 0.8135\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 9\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.4192 - accuracy: 0.8017 - val_loss: 0.4121 - val_accuracy: 0.8084\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 10\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.4061 - accuracy: 0.8086 - val_loss: 0.4031 - val_accuracy: 0.8193\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as lstm_cell_layer_call_fn, lstm_cell_layer_call_and_return_conditional_losses, lstm_cell_1_layer_call_fn, lstm_cell_1_layer_call_and_return_conditional_losses while saving (showing 4 of 4). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 11\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.3981 - accuracy: 0.8123 - val_loss: 0.3872 - val_accuracy: 0.8107\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 12\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.3777 - accuracy: 0.8185 - val_loss: 0.3677 - val_accuracy: 0.8259\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as lstm_cell_layer_call_fn, lstm_cell_layer_call_and_return_conditional_losses, lstm_cell_1_layer_call_fn, lstm_cell_1_layer_call_and_return_conditional_losses while saving (showing 4 of 4). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 13\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.3764 - accuracy: 0.8188 - val_loss: 0.3663 - val_accuracy: 0.8296\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as lstm_cell_layer_call_fn, lstm_cell_layer_call_and_return_conditional_losses, lstm_cell_1_layer_call_fn, lstm_cell_1_layer_call_and_return_conditional_losses while saving (showing 4 of 4). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 14\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.3385 - accuracy: 0.8416 - val_loss: 0.3905 - val_accuracy: 0.8242\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 15\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.3414 - accuracy: 0.8322 - val_loss: 0.3478 - val_accuracy: 0.8345\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as lstm_cell_layer_call_fn, lstm_cell_layer_call_and_return_conditional_losses, lstm_cell_1_layer_call_fn, lstm_cell_1_layer_call_and_return_conditional_losses while saving (showing 4 of 4). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 16\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.3182 - accuracy: 0.8495 - val_loss: 0.3659 - val_accuracy: 0.8411\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as lstm_cell_layer_call_fn, lstm_cell_layer_call_and_return_conditional_losses, lstm_cell_1_layer_call_fn, lstm_cell_1_layer_call_and_return_conditional_losses while saving (showing 4 of 4). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 17\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.2850 - accuracy: 0.8670 - val_loss: 0.2810 - val_accuracy: 0.8706\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as lstm_cell_layer_call_fn, lstm_cell_layer_call_and_return_conditional_losses, lstm_cell_1_layer_call_fn, lstm_cell_1_layer_call_and_return_conditional_losses while saving (showing 4 of 4). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 18\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.2714 - accuracy: 0.8788 - val_loss: 0.2722 - val_accuracy: 0.8801\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as lstm_cell_layer_call_fn, lstm_cell_layer_call_and_return_conditional_losses, lstm_cell_1_layer_call_fn, lstm_cell_1_layer_call_and_return_conditional_losses while saving (showing 4 of 4). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 19\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.2575 - accuracy: 0.8821 - val_loss: 0.2905 - val_accuracy: 0.8597\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 20\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.2424 - accuracy: 0.8949 - val_loss: 0.2713 - val_accuracy: 0.8807\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as lstm_cell_layer_call_fn, lstm_cell_layer_call_and_return_conditional_losses, lstm_cell_1_layer_call_fn, lstm_cell_1_layer_call_and_return_conditional_losses while saving (showing 4 of 4). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 21\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.2115 - accuracy: 0.9132 - val_loss: 0.2368 - val_accuracy: 0.8916\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as lstm_cell_layer_call_fn, lstm_cell_layer_call_and_return_conditional_losses, lstm_cell_1_layer_call_fn, lstm_cell_1_layer_call_and_return_conditional_losses while saving (showing 4 of 4). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 22\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.2102 - accuracy: 0.9115 - val_loss: 0.2736 - val_accuracy: 0.8732\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 23\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.2691 - accuracy: 0.8830 - val_loss: 0.4848 - val_accuracy: 0.7960\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 24\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.4745 - accuracy: 0.7932 - val_loss: 0.4497 - val_accuracy: 0.7963\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 25\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.4520 - accuracy: 0.7927 - val_loss: 0.4346 - val_accuracy: 0.8024\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 26\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.4401 - accuracy: 0.7975 - val_loss: 0.4288 - val_accuracy: 0.8035\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 27\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.4289 - accuracy: 0.7969 - val_loss: 0.4119 - val_accuracy: 0.8012\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 28\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.4194 - accuracy: 0.7967 - val_loss: 0.4140 - val_accuracy: 0.8087\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 29\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.4117 - accuracy: 0.8019 - val_loss: 0.4136 - val_accuracy: 0.8127\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 30\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.4101 - accuracy: 0.8012 - val_loss: 0.3979 - val_accuracy: 0.8110\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 31\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.3962 - accuracy: 0.8072 - val_loss: 0.4148 - val_accuracy: 0.8041\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 32\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.3928 - accuracy: 0.8115 - val_loss: 0.3912 - val_accuracy: 0.8161\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 33\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.4020 - accuracy: 0.8112 - val_loss: 0.3934 - val_accuracy: 0.8078\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 34\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.3817 - accuracy: 0.8157 - val_loss: 0.3817 - val_accuracy: 0.8250\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 35\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.3711 - accuracy: 0.8210 - val_loss: 0.3750 - val_accuracy: 0.8242\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 36\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.3736 - accuracy: 0.8199 - val_loss: 0.3681 - val_accuracy: 0.8282\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 37\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.3637 - accuracy: 0.8236 - val_loss: 0.3656 - val_accuracy: 0.8267\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 38\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.3623 - accuracy: 0.8243 - val_loss: 0.3830 - val_accuracy: 0.8273\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 39\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.3466 - accuracy: 0.8330 - val_loss: 0.3459 - val_accuracy: 0.8385\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 40\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.3624 - accuracy: 0.8242 - val_loss: 0.3494 - val_accuracy: 0.8345\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 41\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.3426 - accuracy: 0.8329 - val_loss: 0.3706 - val_accuracy: 0.8250\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 42\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.3384 - accuracy: 0.8334 - val_loss: 0.3431 - val_accuracy: 0.8394\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 43\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.3377 - accuracy: 0.8328 - val_loss: 0.3385 - val_accuracy: 0.8379\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 44\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.3208 - accuracy: 0.8438 - val_loss: 0.3123 - val_accuracy: 0.8566\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 45\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.3257 - accuracy: 0.8372 - val_loss: 0.3740 - val_accuracy: 0.8227\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 46\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.3191 - accuracy: 0.8440 - val_loss: 0.3095 - val_accuracy: 0.8511\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 47\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.3162 - accuracy: 0.8417 - val_loss: 0.3269 - val_accuracy: 0.8391\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 48\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.2914 - accuracy: 0.8567 - val_loss: 0.2966 - val_accuracy: 0.8548\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 49\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.3087 - accuracy: 0.8497 - val_loss: 0.3066 - val_accuracy: 0.8626\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 50\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.2932 - accuracy: 0.8534 - val_loss: 0.3036 - val_accuracy: 0.8577\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 51\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.2790 - accuracy: 0.8621 - val_loss: 0.2679 - val_accuracy: 0.8715\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 52\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.2687 - accuracy: 0.8642 - val_loss: 0.3122 - val_accuracy: 0.8425\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 53\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.2770 - accuracy: 0.8657 - val_loss: 0.2578 - val_accuracy: 0.8755\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 54\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.2665 - accuracy: 0.8683 - val_loss: 0.2558 - val_accuracy: 0.8769\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 55\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.2556 - accuracy: 0.8763 - val_loss: 0.3180 - val_accuracy: 0.8451\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 56\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.2524 - accuracy: 0.8759 - val_loss: 0.2439 - val_accuracy: 0.8778\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 57\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.2589 - accuracy: 0.8746 - val_loss: 0.2636 - val_accuracy: 0.8821\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 58\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.2376 - accuracy: 0.8839 - val_loss: 0.2424 - val_accuracy: 0.8881\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 59\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.2373 - accuracy: 0.8876 - val_loss: 0.2362 - val_accuracy: 0.8944\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as lstm_cell_layer_call_fn, lstm_cell_layer_call_and_return_conditional_losses, lstm_cell_1_layer_call_fn, lstm_cell_1_layer_call_and_return_conditional_losses while saving (showing 4 of 4). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 60\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.2129 - accuracy: 0.8989 - val_loss: 0.2433 - val_accuracy: 0.8835\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 61\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.2105 - accuracy: 0.9008 - val_loss: 0.2109 - val_accuracy: 0.9002\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as lstm_cell_layer_call_fn, lstm_cell_layer_call_and_return_conditional_losses, lstm_cell_1_layer_call_fn, lstm_cell_1_layer_call_and_return_conditional_losses while saving (showing 4 of 4). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 62\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.1999 - accuracy: 0.9078 - val_loss: 0.2602 - val_accuracy: 0.8867\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 63\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.1926 - accuracy: 0.9100 - val_loss: 0.2599 - val_accuracy: 0.8878\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 64\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.1962 - accuracy: 0.9065 - val_loss: 0.2025 - val_accuracy: 0.9088\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as lstm_cell_layer_call_fn, lstm_cell_layer_call_and_return_conditional_losses, lstm_cell_1_layer_call_fn, lstm_cell_1_layer_call_and_return_conditional_losses while saving (showing 4 of 4). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 65\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.1694 - accuracy: 0.9219 - val_loss: 0.1958 - val_accuracy: 0.9171\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as lstm_cell_layer_call_fn, lstm_cell_layer_call_and_return_conditional_losses, lstm_cell_1_layer_call_fn, lstm_cell_1_layer_call_and_return_conditional_losses while saving (showing 4 of 4). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 66\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.1557 - accuracy: 0.9296 - val_loss: 0.1979 - val_accuracy: 0.9137\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 67\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.2079 - accuracy: 0.9056 - val_loss: 0.2073 - val_accuracy: 0.9068\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 68\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.1606 - accuracy: 0.9247 - val_loss: 0.1967 - val_accuracy: 0.9111\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 69\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.2017 - accuracy: 0.9121 - val_loss: 0.2636 - val_accuracy: 0.8898\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 70\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.1549 - accuracy: 0.9316 - val_loss: 0.2079 - val_accuracy: 0.9065\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 71\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.1458 - accuracy: 0.9370 - val_loss: 0.2022 - val_accuracy: 0.9197\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as lstm_cell_layer_call_fn, lstm_cell_layer_call_and_return_conditional_losses, lstm_cell_1_layer_call_fn, lstm_cell_1_layer_call_and_return_conditional_losses while saving (showing 4 of 4). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 72\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.1415 - accuracy: 0.9381 - val_loss: 0.2115 - val_accuracy: 0.9119\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 73\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.1573 - accuracy: 0.9312 - val_loss: 0.1680 - val_accuracy: 0.9323\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as lstm_cell_layer_call_fn, lstm_cell_layer_call_and_return_conditional_losses, lstm_cell_1_layer_call_fn, lstm_cell_1_layer_call_and_return_conditional_losses while saving (showing 4 of 4). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 74\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.1249 - accuracy: 0.9465 - val_loss: 0.1803 - val_accuracy: 0.9214\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 75\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.1386 - accuracy: 0.9385 - val_loss: 0.1770 - val_accuracy: 0.9225\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 76\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.1364 - accuracy: 0.9403 - val_loss: 0.1678 - val_accuracy: 0.9297\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 77\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.1508 - accuracy: 0.9357 - val_loss: 0.1554 - val_accuracy: 0.9355\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as lstm_cell_layer_call_fn, lstm_cell_layer_call_and_return_conditional_losses, lstm_cell_1_layer_call_fn, lstm_cell_1_layer_call_and_return_conditional_losses while saving (showing 4 of 4). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 78\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.1309 - accuracy: 0.9449 - val_loss: 0.1604 - val_accuracy: 0.9355\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 79\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.1145 - accuracy: 0.9514 - val_loss: 0.2346 - val_accuracy: 0.9148\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 80\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.1774 - accuracy: 0.9269 - val_loss: 0.1618 - val_accuracy: 0.9309\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 81\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.1731 - accuracy: 0.9281 - val_loss: 0.2017 - val_accuracy: 0.9114\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 82\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.1214 - accuracy: 0.9502 - val_loss: 0.1600 - val_accuracy: 0.9375\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as lstm_cell_layer_call_fn, lstm_cell_layer_call_and_return_conditional_losses, lstm_cell_1_layer_call_fn, lstm_cell_1_layer_call_and_return_conditional_losses while saving (showing 4 of 4). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 83\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.1299 - accuracy: 0.9466 - val_loss: 0.2129 - val_accuracy: 0.9131\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 84\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.1549 - accuracy: 0.9383 - val_loss: 0.1509 - val_accuracy: 0.9375\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 85\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.1040 - accuracy: 0.9563 - val_loss: 0.1430 - val_accuracy: 0.9446\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as lstm_cell_layer_call_fn, lstm_cell_layer_call_and_return_conditional_losses, lstm_cell_1_layer_call_fn, lstm_cell_1_layer_call_and_return_conditional_losses while saving (showing 4 of 4). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 86\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.1206 - accuracy: 0.9489 - val_loss: 0.1710 - val_accuracy: 0.9398\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 87\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.1087 - accuracy: 0.9571 - val_loss: 0.1646 - val_accuracy: 0.9357\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 88\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.1006 - accuracy: 0.9611 - val_loss: 0.1536 - val_accuracy: 0.9429\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 89\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.2074 - accuracy: 0.9220 - val_loss: 0.2625 - val_accuracy: 0.8864\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 90\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.1269 - accuracy: 0.9500 - val_loss: 0.1554 - val_accuracy: 0.9372\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 91\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.1213 - accuracy: 0.9543 - val_loss: 0.1486 - val_accuracy: 0.9395\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 92\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.1070 - accuracy: 0.9559 - val_loss: 0.1458 - val_accuracy: 0.9432\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 93\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.0906 - accuracy: 0.9637 - val_loss: 0.1597 - val_accuracy: 0.9355\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 94\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.0816 - accuracy: 0.9702 - val_loss: 0.1338 - val_accuracy: 0.9492\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as lstm_cell_layer_call_fn, lstm_cell_layer_call_and_return_conditional_losses, lstm_cell_1_layer_call_fn, lstm_cell_1_layer_call_and_return_conditional_losses while saving (showing 4 of 4). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-only/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 95\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.0881 - accuracy: 0.9656 - val_loss: 0.1786 - val_accuracy: 0.9283\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 96\n",
      "105/105 [==============================] - 1s 6ms/step - loss: 0.0973 - accuracy: 0.9617 - val_loss: 0.1565 - val_accuracy: 0.9415\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 97\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.0825 - accuracy: 0.9691 - val_loss: 0.1452 - val_accuracy: 0.9455\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 98\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.0902 - accuracy: 0.9636 - val_loss: 0.1723 - val_accuracy: 0.9355\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration: 99\n",
      "105/105 [==============================] - 1s 5ms/step - loss: 0.1007 - accuracy: 0.9615 - val_loss: 0.1771 - val_accuracy: 0.9300\n"
     ]
    }
   ],
   "source": [
    "# Init best accuracy with 0\n",
    "best_acc = 0\n",
    "# Save all training loss\n",
    "train_loss = []\n",
    "# Save all validation loss\n",
    "val_loss = []\n",
    "# Loop for the number of epochs\n",
    "for iteration in range(100):\n",
    "    print()\n",
    "    print('-' * 50)\n",
    "    print('Iteration:', iteration)\n",
    "    \n",
    "    # Loss and Acc with each epoch\n",
    "    loss = []\n",
    "    acc = []\n",
    "    \n",
    "    # Fit the model in batches of 100\n",
    "    history = model.fit( X_train, y_train, batch_size = 100, epochs=1, validation_data=(X_test, y_test))\n",
    "    train_loss.append(history.history['loss'][0])\n",
    "    val_loss.append(history.history['val_loss'][0])\n",
    "    \n",
    "    # If val_accuracy improves from the last saved best_accuracy, then save model\n",
    "    if history.history['val_accuracy'][0] > best_acc and history.history['val_accuracy'][0] > .80:\n",
    "        print('Saving Model...')\n",
    "        model.save('lstm-many-to-one-data-only')\n",
    "        best_acc = history.history['val_accuracy'][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f995e37",
   "metadata": {},
   "source": [
    "## Plotting Epochs vs. Training loss (Binary Cross Entropy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "bf26c6e6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(val_loss, label='Validation')\n",
    "plt.plot(train_loss, label='Train')\n",
    "plt.legend()\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Binary Cross Entropy')\n",
    "plt.title('Loss for LSTM using Tabular Data')\n",
    "plt.savefig('Losses_data_only.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4c6c9c7",
   "metadata": {},
   "source": [
    "The training loss and validation loss has decreased monotonically, with one peak."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9cb78da7",
   "metadata": {},
   "source": [
    "## Testing the model on the test set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "19ac23f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow import keras\n",
    "\n",
    "# Loading the model\n",
    "model_pretrained = keras.models.load_model('lstm-many-to-one-data-only')\n",
    "\n",
    "# Prediction using X_test\n",
    "pred = model_pretrained(X_test)\n",
    "# Convert to array\n",
    "pred = np.array(pred)\n",
    "\n",
    "# Assigning class based on prediction\n",
    "pred[pred > 0.5] = 1\n",
    "pred[pred != 1] = 0\n",
    "\n",
    "# Class-wise accuracy\n",
    "classwise1 = ((np.array(pred)[:,0] == np.array(y_test))*(y_test==1)).sum()/(y_test==1).sum()\n",
    "classwise0 = ((np.array(pred)[:,0] == np.array(y_test))*(y_test==0)).sum()/(y_test==0).sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c162547",
   "metadata": {},
   "source": [
    "## Classwise accuracy and overall accuracy on test data "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "5b78838d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Accuracy: \t 94.923\n",
      "------------------------------\n",
      "--Class wise Accuracy of Test--\n",
      "------------------------------\n",
      "Class 0: \t 97.586\n",
      "Class 1: \t 84.507\n"
     ]
    }
   ],
   "source": [
    "print(f'Total Accuracy: \\t {((np.array(pred)[:,0] == np.array(y_test)).sum()/len(pred))*100:.3f}')\n",
    "print('-'*30)\n",
    "\n",
    "print('--Class wise Accuracy of Test--')\n",
    "print('-'*30)\n",
    "print(f'Class 0: \\t {classwise0*100:.3f}')\n",
    "print(f'Class 1: \\t {classwise1*100:.3f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9840588",
   "metadata": {},
   "source": [
    "# 2. Combination model with CNN and RNN using satellite images and numerical meteorological data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9abe7c82",
   "metadata": {},
   "source": [
    "**About the architecture:**\n",
    "- First, we stack the images in channels (i.e. 1 channel for grayscale), and then pass them through multiple layers of Convolutions with kernel/filter size 3 x 3 and stride 2 x 2\n",
    "- To be precise, we use 6 convolution layers with 3, 6, 6, 8, 8, 8 filter counts at respective layers\n",
    "- By keeping zero padding and stride 2 x 2, we reduce the image size by half through each layer, resulting in final activation size as 1 x 1 x 8 (i.e. output of final convolution layer)\n",
    "- We then flatten this output and concatenate them with the 1 x 16 dimension output of LSTM that we discussed in the previous section\n",
    "- Finally, we use a dense layer with 1 neuron to predict the output between 0 and 1 (due to the sigmoid activation)\n",
    "\n",
    "**Intuition:**\n",
    "- By concatenating the output from the ConvNet to the LSTM output, we infuse the information from images with the tabular data which in turn provides more information to predict the decision boundary\n",
    "- We stack multiple convolution layers to enable complex feature extraction\n",
    "- The convolution filters in the channel depth learn to fuse the information in time domain, as we stack the temporal frames in channels\n",
    "- More intuitively, these act as a fully connected LSTM layers rather than feedforward LSTM layers\n",
    "- We also tried using TimeDistributed Conv layers to pass into the LSTM, but found that the model does not learn and finds no improvement in both training and validation accuracies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "0249db17",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_1\"\n",
      "__________________________________________________________________________________________________\n",
      " Layer (type)                   Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      " input_2 (InputLayer)           [(None, 48, 48, 35)  0           []                               \n",
      "                                ]                                                                 \n",
      "                                                                                                  \n",
      " conv2d (Conv2D)                (None, 24, 24, 3)    948         ['input_2[0][0]']                \n",
      "                                                                                                  \n",
      " conv2d_1 (Conv2D)              (None, 12, 12, 6)    168         ['conv2d[0][0]']                 \n",
      "                                                                                                  \n",
      " conv2d_2 (Conv2D)              (None, 6, 6, 6)      330         ['conv2d_1[0][0]']               \n",
      "                                                                                                  \n",
      " conv2d_3 (Conv2D)              (None, 3, 3, 8)      440         ['conv2d_2[0][0]']               \n",
      "                                                                                                  \n",
      " input_3 (InputLayer)           [(None, 35, 10)]     0           []                               \n",
      "                                                                                                  \n",
      " conv2d_4 (Conv2D)              (None, 2, 2, 8)      584         ['conv2d_3[0][0]']               \n",
      "                                                                                                  \n",
      " lstm_2 (LSTM)                  (None, 35, 16)       1728        ['input_3[0][0]']                \n",
      "                                                                                                  \n",
      " conv2d_5 (Conv2D)              (None, 1, 1, 8)      584         ['conv2d_4[0][0]']               \n",
      "                                                                                                  \n",
      " lstm_3 (LSTM)                  (None, 16)           2112        ['lstm_2[0][0]']                 \n",
      "                                                                                                  \n",
      " flatten (Flatten)              (None, 8)            0           ['conv2d_5[0][0]']               \n",
      "                                                                                                  \n",
      " concatenate (Concatenate)      (None, 24)           0           ['lstm_3[0][0]',                 \n",
      "                                                                  'flatten[0][0]']                \n",
      "                                                                                                  \n",
      " dense_1 (Dense)                (None, 1)            25          ['concatenate[0][0]']            \n",
      "                                                                                                  \n",
      "==================================================================================================\n",
      "Total params: 6,919\n",
      "Trainable params: 6,919\n",
      "Non-trainable params: 0\n",
      "__________________________________________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "RNN = layers.LSTM\n",
    "img_shape = (48, 48, 35)\n",
    "data_shape = (35, 10)\n",
    "\n",
    "image = layers.Input(shape=img_shape)\n",
    "data = layers.Input(shape= data_shape)\n",
    "\n",
    "# Define the CNN for images\n",
    "# filter => 3x3\n",
    "# stride => 2x2\n",
    "conv1 = layers.Conv2D(3, (3, 3), (2,2), padding='same', activation='selu')(image)\n",
    "conv2 = layers.Conv2D(6, (3, 3), (2,2), padding='same', activation='selu')(conv1)\n",
    "conv3 = layers.Conv2D(6, (3, 3), (2,2), padding='same', activation='selu')(conv2)\n",
    "conv4 = layers.Conv2D(8, (3, 3), (2,2), padding='same', activation='selu')(conv3)\n",
    "conv5 = layers.Conv2D(8, (3, 3), (2,2), padding='same', activation='selu')(conv4)\n",
    "conv6 = layers.Conv2D(8, (3, 3), (2,2), padding='same', activation='selu')(conv5)\n",
    "\n",
    "# LSTM neurons\n",
    "hidden_size = 16\n",
    "\n",
    "# Define layers in RNN\n",
    "lstm1 = RNN(hidden_size, input_shape=(35, data_shape[1]), return_sequences= True)(data)\n",
    "lstm2 = RNN(hidden_size, input_shape=(35, hidden_size), return_sequences= False)(lstm1)\n",
    "\n",
    "# Flatten the output of CNN\n",
    "flattened = layers.Flatten()(conv6)\n",
    "\n",
    "# Connect the CNN output and RNN output to a dense layer with 1 neuron for final 0/1 outputs\n",
    "final = layers.Concatenate(axis=1)([lstm2, flattened])\n",
    "out = layers.Dense(1, activation='sigmoid')(final)\n",
    "\n",
    "# Using both, images and numerical data as input\n",
    "model = Model([image, data], out)  \n",
    "\n",
    "# Optimizer\n",
    "optim = Adam(learning_rate=0.01)\n",
    "\n",
    "# Build model\n",
    "model.compile(loss='binary_crossentropy',\n",
    "              optimizer = optim,\n",
    "              metrics=['accuracy'])\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5aa8f02",
   "metadata": {},
   "source": [
    "## Training the CNN + RNN Combination model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "03659ce7",
   "metadata": {},
   "outputs": [],
   "source": [
    "imgs_test = np.load('images_test.npy')\n",
    "imgs_train =  np.load('images_train.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "fa81d836",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration 0\n",
      "105/105 [==============================] - 4s 17ms/step - loss: 0.4905 - accuracy: 0.7882 - val_loss: 0.4556 - val_accuracy: 0.7963\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 1\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.4528 - accuracy: 0.7955 - val_loss: 0.4395 - val_accuracy: 0.8075\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 10). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration 2\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.4469 - accuracy: 0.7983 - val_loss: 0.4393 - val_accuracy: 0.7966\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 3\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.4383 - accuracy: 0.8000 - val_loss: 0.4241 - val_accuracy: 0.8061\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 4\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.4295 - accuracy: 0.8026 - val_loss: 0.4373 - val_accuracy: 0.8101\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 10). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration 5\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.4299 - accuracy: 0.8050 - val_loss: 0.4194 - val_accuracy: 0.8138\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 10). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration 6\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.4184 - accuracy: 0.8072 - val_loss: 0.4120 - val_accuracy: 0.8101\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 7\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.4092 - accuracy: 0.8147 - val_loss: 0.4087 - val_accuracy: 0.8118\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 8\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.4087 - accuracy: 0.8088 - val_loss: 0.4087 - val_accuracy: 0.8150\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 10). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration 9\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.3878 - accuracy: 0.8179 - val_loss: 0.4104 - val_accuracy: 0.7966\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 10\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.3740 - accuracy: 0.8202 - val_loss: 0.3825 - val_accuracy: 0.8250\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 10). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration 11\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.3581 - accuracy: 0.8312 - val_loss: 0.3432 - val_accuracy: 0.8419\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 10). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration 12\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.3413 - accuracy: 0.8413 - val_loss: 0.4830 - val_accuracy: 0.7952\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 13\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.4736 - accuracy: 0.7943 - val_loss: 0.4465 - val_accuracy: 0.7969\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 14\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.4447 - accuracy: 0.7985 - val_loss: 0.4370 - val_accuracy: 0.8110\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 15\n",
      "105/105 [==============================] - 1s 11ms/step - loss: 0.4510 - accuracy: 0.7983 - val_loss: 0.4314 - val_accuracy: 0.8107\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 16\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.4370 - accuracy: 0.7972 - val_loss: 0.4282 - val_accuracy: 0.8118\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 17\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.4328 - accuracy: 0.7978 - val_loss: 0.4221 - val_accuracy: 0.7949\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 18\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.4287 - accuracy: 0.8007 - val_loss: 0.4388 - val_accuracy: 0.8095\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 19\n",
      "105/105 [==============================] - 1s 11ms/step - loss: 0.4355 - accuracy: 0.7980 - val_loss: 0.4160 - val_accuracy: 0.8115\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 20\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.4184 - accuracy: 0.8039 - val_loss: 0.4099 - val_accuracy: 0.8087\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 21\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.4194 - accuracy: 0.8025 - val_loss: 0.4341 - val_accuracy: 0.8044\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 22\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.4046 - accuracy: 0.8074 - val_loss: 0.3955 - val_accuracy: 0.8104\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 23\n",
      "105/105 [==============================] - 1s 11ms/step - loss: 0.3922 - accuracy: 0.8149 - val_loss: 0.3872 - val_accuracy: 0.8207\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 24\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.3803 - accuracy: 0.8180 - val_loss: 0.3705 - val_accuracy: 0.8308\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 25\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.3799 - accuracy: 0.8215 - val_loss: 0.3603 - val_accuracy: 0.8425\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 10). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration 26\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.3545 - accuracy: 0.8354 - val_loss: 0.3445 - val_accuracy: 0.8405\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 27\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.3302 - accuracy: 0.8478 - val_loss: 0.3386 - val_accuracy: 0.8437\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 10). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration 28\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.3223 - accuracy: 0.8502 - val_loss: 0.3491 - val_accuracy: 0.8319\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 29\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.2930 - accuracy: 0.8679 - val_loss: 0.3041 - val_accuracy: 0.8592\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 10). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration 30\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.2690 - accuracy: 0.8789 - val_loss: 0.3042 - val_accuracy: 0.8715\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 10). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration 31\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.2516 - accuracy: 0.8870 - val_loss: 0.2490 - val_accuracy: 0.8887\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 10). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration 32\n",
      "105/105 [==============================] - 1s 11ms/step - loss: 0.2396 - accuracy: 0.8939 - val_loss: 0.2618 - val_accuracy: 0.8781\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 33\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.2199 - accuracy: 0.9061 - val_loss: 0.2167 - val_accuracy: 0.9048\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 10). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration 34\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.2071 - accuracy: 0.9137 - val_loss: 0.1995 - val_accuracy: 0.9105\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 10). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration 35\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.1931 - accuracy: 0.9195 - val_loss: 0.2084 - val_accuracy: 0.9073\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 36\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.1763 - accuracy: 0.9265 - val_loss: 0.2437 - val_accuracy: 0.8916\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 37\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.1822 - accuracy: 0.9232 - val_loss: 0.1746 - val_accuracy: 0.9237\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 10). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration 38\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.1532 - accuracy: 0.9341 - val_loss: 0.1748 - val_accuracy: 0.9277\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 10). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration 39\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.1554 - accuracy: 0.9361 - val_loss: 0.1655 - val_accuracy: 0.9297\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 10). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration 40\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.1494 - accuracy: 0.9413 - val_loss: 0.1538 - val_accuracy: 0.9355\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 10). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration 41\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.1318 - accuracy: 0.9478 - val_loss: 0.1361 - val_accuracy: 0.9429\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 10). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration 42\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.1136 - accuracy: 0.9570 - val_loss: 0.1223 - val_accuracy: 0.9507\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 10). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration 43\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.1047 - accuracy: 0.9592 - val_loss: 0.1410 - val_accuracy: 0.9418\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 44\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.1246 - accuracy: 0.9518 - val_loss: 0.1180 - val_accuracy: 0.9552\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 10). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration 45\n",
      "105/105 [==============================] - 1s 11ms/step - loss: 0.1392 - accuracy: 0.9419 - val_loss: 0.1868 - val_accuracy: 0.9205\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 46\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.1432 - accuracy: 0.9411 - val_loss: 0.1492 - val_accuracy: 0.9395\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 47\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.1152 - accuracy: 0.9524 - val_loss: 0.1055 - val_accuracy: 0.9575\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 10). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration 48\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.1014 - accuracy: 0.9607 - val_loss: 0.1112 - val_accuracy: 0.9593\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 10). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration 49\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0911 - accuracy: 0.9648 - val_loss: 0.1387 - val_accuracy: 0.9438\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 50\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0886 - accuracy: 0.9670 - val_loss: 0.1024 - val_accuracy: 0.9621\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 10). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration 51\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0850 - accuracy: 0.9675 - val_loss: 0.1151 - val_accuracy: 0.9558\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 52\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0791 - accuracy: 0.9701 - val_loss: 0.1338 - val_accuracy: 0.9487\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 53\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0781 - accuracy: 0.9692 - val_loss: 0.2686 - val_accuracy: 0.9056\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 54\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.4457 - accuracy: 0.7951 - val_loss: 0.3583 - val_accuracy: 0.8216\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 55\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.3204 - accuracy: 0.8308 - val_loss: 0.2826 - val_accuracy: 0.8543\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 56\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.2555 - accuracy: 0.8651 - val_loss: 0.2455 - val_accuracy: 0.8853\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 57\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.2226 - accuracy: 0.8883 - val_loss: 0.2133 - val_accuracy: 0.8993\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 58\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.1800 - accuracy: 0.9159 - val_loss: 0.2013 - val_accuracy: 0.9102\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 59\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.1498 - accuracy: 0.9327 - val_loss: 0.1739 - val_accuracy: 0.9116\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 60\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.1328 - accuracy: 0.9412 - val_loss: 0.1447 - val_accuracy: 0.9400\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 61\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.1262 - accuracy: 0.9445 - val_loss: 0.1428 - val_accuracy: 0.9363\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 62\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.1138 - accuracy: 0.9526 - val_loss: 0.1545 - val_accuracy: 0.9334\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 63\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.1056 - accuracy: 0.9561 - val_loss: 0.1352 - val_accuracy: 0.9400\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 64\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.1012 - accuracy: 0.9588 - val_loss: 0.2549 - val_accuracy: 0.9065\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 65\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.1217 - accuracy: 0.9520 - val_loss: 0.1146 - val_accuracy: 0.9538\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 66\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0897 - accuracy: 0.9640 - val_loss: 0.1073 - val_accuracy: 0.9598\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 67\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0757 - accuracy: 0.9692 - val_loss: 0.1188 - val_accuracy: 0.9512\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 68\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0839 - accuracy: 0.9665 - val_loss: 0.0974 - val_accuracy: 0.9581\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 69\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0710 - accuracy: 0.9719 - val_loss: 0.1059 - val_accuracy: 0.9613\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 70\n",
      "105/105 [==============================] - 1s 14ms/step - loss: 0.0868 - accuracy: 0.9666 - val_loss: 0.1338 - val_accuracy: 0.9464\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 71\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0843 - accuracy: 0.9681 - val_loss: 0.1157 - val_accuracy: 0.9567\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 72\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0673 - accuracy: 0.9749 - val_loss: 0.0918 - val_accuracy: 0.9650\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 10). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration 73\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0672 - accuracy: 0.9734 - val_loss: 0.0913 - val_accuracy: 0.9650\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 74\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0804 - accuracy: 0.9703 - val_loss: 0.0753 - val_accuracy: 0.9707\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 10). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration 75\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0608 - accuracy: 0.9760 - val_loss: 0.0992 - val_accuracy: 0.9650\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 76\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0660 - accuracy: 0.9752 - val_loss: 0.0778 - val_accuracy: 0.9702\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 77\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0596 - accuracy: 0.9782 - val_loss: 0.0795 - val_accuracy: 0.9673\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 78\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0566 - accuracy: 0.9778 - val_loss: 0.0709 - val_accuracy: 0.9739\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 10). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration 79\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0703 - accuracy: 0.9728 - val_loss: 0.1212 - val_accuracy: 0.9507\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 80\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0506 - accuracy: 0.9800 - val_loss: 0.0735 - val_accuracy: 0.9716\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 81\n",
      "105/105 [==============================] - 1s 11ms/step - loss: 0.0409 - accuracy: 0.9858 - val_loss: 0.0640 - val_accuracy: 0.9745\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 10). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration 82\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0705 - accuracy: 0.9731 - val_loss: 0.0753 - val_accuracy: 0.9705\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 83\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0501 - accuracy: 0.9803 - val_loss: 0.0698 - val_accuracy: 0.9707\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 84\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0780 - accuracy: 0.9721 - val_loss: 0.0765 - val_accuracy: 0.9719\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 85\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.1259 - accuracy: 0.9526 - val_loss: 0.2687 - val_accuracy: 0.8973\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 86\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.1139 - accuracy: 0.9550 - val_loss: 0.0802 - val_accuracy: 0.9639\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 87\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0491 - accuracy: 0.9806 - val_loss: 0.0763 - val_accuracy: 0.9684\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 88\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0489 - accuracy: 0.9825 - val_loss: 0.0681 - val_accuracy: 0.9739\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 89\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0431 - accuracy: 0.9839 - val_loss: 0.0652 - val_accuracy: 0.9765\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 10). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration 90\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0617 - accuracy: 0.9791 - val_loss: 0.1349 - val_accuracy: 0.9527\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 91\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0612 - accuracy: 0.9760 - val_loss: 0.0739 - val_accuracy: 0.9710\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 92\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0368 - accuracy: 0.9865 - val_loss: 0.0972 - val_accuracy: 0.9630\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 93\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0450 - accuracy: 0.9842 - val_loss: 0.1077 - val_accuracy: 0.9613\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 94\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0511 - accuracy: 0.9814 - val_loss: 0.0787 - val_accuracy: 0.9699\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 95\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0360 - accuracy: 0.9858 - val_loss: 0.1367 - val_accuracy: 0.9596\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 96\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0452 - accuracy: 0.9832 - val_loss: 0.0938 - val_accuracy: 0.9653\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 97\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0545 - accuracy: 0.9801 - val_loss: 0.0584 - val_accuracy: 0.9773\n",
      "Saving Model...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 10). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: lstm-many-to-one-data-and-images/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------\n",
      "Iteration 98\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0483 - accuracy: 0.9836 - val_loss: 0.1242 - val_accuracy: 0.9541\n",
      "\n",
      "--------------------------------------------------\n",
      "Iteration 99\n",
      "105/105 [==============================] - 1s 10ms/step - loss: 0.0779 - accuracy: 0.9700 - val_loss: 0.0953 - val_accuracy: 0.9644\n"
     ]
    }
   ],
   "source": [
    "# Init best accuracy with 0\n",
    "best_acc = 0\n",
    "# Save all training loss\n",
    "train_loss = []\n",
    "# Save all validation loss\n",
    "val_loss = []\n",
    "# reshape imgs_train and imgs_test\n",
    "imgs_train = np.einsum('ijkl->iklj', imgs_train[:,:,:,:,0])\n",
    "imgs_test = np.einsum('ijkl->iklj', imgs_test[:,:,:,:,0])\n",
    "# Loop for the number of epochs\n",
    "for iteration in range(100):\n",
    "    print()\n",
    "    print('-' * 50)\n",
    "    print('Iteration', iteration)\n",
    "    \n",
    "    # Loss and Acc with each epoch\n",
    "    loss = []\n",
    "    acc = []\n",
    "    \n",
    "    # Fit the model in batches of 100\n",
    "    history = model.fit( [imgs_train, X_train], y_train, batch_size = 100, epochs=1, validation_data=( [imgs_test, X_test], y_test))\n",
    "    train_loss.append(history.history['loss'][0])\n",
    "    val_loss.append(history.history['val_loss'][0])\n",
    "    # If val_accuracy improves from the last saved best_accuracy, then save model\n",
    "    if history.history['val_accuracy'][0] > best_acc and history.history['val_accuracy'][0] > .80:\n",
    "        print('Saving Model...')\n",
    "        model.save('lstm-many-to-one-data-and-images')\n",
    "        best_acc = history.history['val_accuracy'][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d64ad26",
   "metadata": {},
   "source": [
    "## Plotting Epochs vs. Training loss (Binary Cross Entropy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "b8db5a1a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(val_loss, label='Validation')\n",
    "plt.plot(train_loss, label='Train')\n",
    "plt.legend()\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Binary Cross Entropy')\n",
    "plt.title('Loss for LSTM using Tabular Data')\n",
    "plt.savefig('Losses_data_and_image.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "939a9a9c",
   "metadata": {},
   "source": [
    "The training loss and validation loss has decreased monotonically, with one peak."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cfe92e82",
   "metadata": {},
   "source": [
    "## Testing the model on the test set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "d53331d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Loading the model\n",
    "model_pretrained = keras.models.load_model('lstm-many-to-one-data-and-images')\n",
    "\n",
    "# Prediction using X_test\n",
    "pred = model_pretrained([imgs_test, X_test])\n",
    "# Convert to array\n",
    "pred = np.array(pred)\n",
    "\n",
    "# Assigning class based on prediction\n",
    "pred[pred>0.5] = 1\n",
    "pred[pred!=1] = 0\n",
    "\n",
    "# Class-wise accuracy\n",
    "classwise1 = ((np.array(pred)[:,0] == np.array(y_test))*(y_test==1)).sum()/(y_test==1).sum()\n",
    "classwise0 = ((np.array(pred)[:,0] == np.array(y_test))*(y_test==0)).sum()/(y_test==0).sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59acd665",
   "metadata": {},
   "source": [
    "## Classwise accuracy and overall accuracy on test data "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "5dc43176",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Accuracy: \t 97.762\n",
      "------------------------------\n",
      "--Class wise Accuracy of Test--\n",
      "------------------------------\n",
      "Class 0: \t 98.199\n",
      "Class 1: \t 96.056\n"
     ]
    }
   ],
   "source": [
    "print(f'Total Accuracy: \\t {((np.array(pred)[:,0] == np.array(y_test)).sum()/len(pred))*100:.3f}')\n",
    "print('-'*30)\n",
    "print('--Class wise Accuracy of Test--')\n",
    "print('-'*30)\n",
    "print(f'Class 0: \\t {classwise0*100:.3f}')\n",
    "print(f'Class 1: \\t {classwise1*100:.3f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf1af0c0",
   "metadata": {},
   "source": [
    "# Conclusion:\n",
    "\n",
    "- The RNN model and the CNN + RNN combination model, both work very well (>90%)\n",
    "    - But due to the images data and ConvNets, the combination model shows a substantial improvement in testing accuracy of 97% compared to 94 % of RNN model.\n",
    "    - We mainly find a major improvement in class wise accuracies. As the combined CNN+RNN model has 96% accuracy for snow prediction while the RNN model has 84.5% (almost a +12% boost!) \n",
    "- **RNN**\n",
    "    - Total Accuracy = `94.923%`\n",
    "    - Class-wise Accuracy\n",
    "        - Class 0 = 97.586%\n",
    "        - Class 1 = 84.507%\n",
    "- **CNN + RNN**\n",
    "    - Total Accuracy = `97.762%`\n",
    "    - Class-wise Accuracy\n",
    "        - Class 0 = 98.199%\n",
    "        - Class 1 = 96.056%\n",
    "- Our baseline of Decision Tree had an accuracy of `54.76%`\n",
    "    - Overall, our CNN + RNN network has shown an improvement of `~42%`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "127d4d04",
   "metadata": {},
   "source": [
    "# Reference\n",
    "- Zeiler. et.al 2013, \"Visualizing and Understanding Convolutional Networks\" (https://arxiv.org/abs/1311.2901)\n",
    "- https://medium.com/@mixanyy/different-ways-to-combine-cnn-and-lstm-networks-for-time-series-classification-tasks-b03fc37e91b6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fbe16d67",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}