KAERI CNN2d Keras 23-06-20.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# DACON Collision detection using vibration data"
      ],
      "metadata": {
        "id": "bciU3DsHk8F5",
        "colab_type": "text"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import gc\n",
        "import os\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "from datetime import datetime, timedelta\n",
        "\n",
        "from matplotlib import pyplot as plt\n",
        "import seaborn as sns\n",
        "\n",
        "from sklearn.preprocessing import LabelEncoder\n",
        "from sklearn.model_selection import KFold, GroupKFold, train_test_split\n",
        "from sklearn.metrics import mean_squared_error, mean_absolute_error\n",
        "from sklearn.linear_model import Lasso\n",
        "from sklearn.linear_model import Ridge\n",
        "\n",
        "from sklearn.experimental import enable_hist_gradient_boosting\n",
        "from sklearn.ensemble import HistGradientBoostingRegressor, RandomForestRegressor\n",
        "\n",
        "import lightgbm  as lgb\n",
        "from lightgbm import LGBMRegressor\n",
        "\n",
        "# import xgboost  as xgb\n",
        "# from xgboost import XGBRegressor\n",
        "\n",
        "import tensorflow as tf\n",
        "from tensorflow.keras.layers import *\n",
        "from tensorflow.keras.callbacks import *\n",
        "from tensorflow.keras.optimizers import *\n",
        "from tensorflow.keras import backend as K\n",
        "import tensorflow_addons as tfa\n"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/statsmodels/tools/_testing.py:19: FutureWarning: pandas.util.testing is deprecated. Use the functions in the public API at pandas.testing instead.\n",
            "  import pandas.util.testing as tm\n"
          ]
        }
      ],
      "execution_count": 1,
      "metadata": {
        "id": "Gbvg75Crk0Ev",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        },
        "outputId": "4182a155-c4e1-41a1-e5b7-d23c4af32312"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Read csv files\n",
        "\n",
        "COLAB = True\n",
        "\n",
        "if COLAB: path = '/content/drive/My Drive/ML Projects/DACON/Colision/data/'\n",
        "else: path = '/ML Projects/DACON/data/'\n",
        "\n",
        "def read_data(path=path):\n",
        "    train_df = pd.read_csv(path+'train_features.csv',)     \n",
        "    train_target = pd.read_csv(path+'train_target.csv', )  \n",
        "    test_df = pd.read_csv(path+'test_features.csv', )                \n",
        "    subm = pd.read_csv(path+\"sample_submission.csv\")\n",
        "    print('Shape of train:', train_df.shape)\n",
        "    print('Shape of solution:', test_df.shape)\n",
        "    print('Shape of submision:', subm.shape)\n",
        "    return train_df, train_target, test_df, subm"
      ],
      "outputs": [],
      "execution_count": 16,
      "metadata": {
        "id": "6JxxcVGlk10H",
        "colab_type": "code",
        "colab": {}
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Helpers"
      ],
      "metadata": {
        "id": "AzoH3pD0n1lA",
        "colab_type": "text"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from tensorflow.keras.callbacks import Callback\n",
        "\n",
        "class LRFinder(Callback):\n",
        "    \n",
        "    '''\n",
        "    A simple callback for finding the optimal learning rate range for your model + dataset. \n",
        "    \n",
        "    # Usage\n",
        "        ```python\n",
        "            lr_finder = LRFinder(min_lr=1e-5, \n",
        "                                 max_lr=1e-2, \n",
        "                                 steps_per_epoch=np.ceil(epoch_size/batch_size), \n",
        "                                 epochs=3)\n",
        "            model.fit(X_train, Y_train, callbacks=[lr_finder])\n",
        "            \n",
        "            lr_finder.plot_loss()\n",
        "        ```\n",
        "    \n",
        "    # Arguments\n",
        "        min_lr: The lower bound of the learning rate range for the experiment.\n",
        "        max_lr: The upper bound of the learning rate range for the experiment.\n",
        "        steps_per_epoch: Number of mini-batches in the dataset. Calculated as `np.ceil(epoch_size/batch_size)`. \n",
        "        epochs: Number of epochs to run experiment. Usually between 2 and 4 epochs is sufficient. \n",
        "        \n",
        "    # References\n",
        "        Blog post: jeremyjordan.me/nn-learning-rate\n",
        "        Original paper: https://arxiv.org/abs/1506.01186\n",
        "    '''\n",
        "    \n",
        "    def __init__(self, min_lr=1e-5, max_lr=1e-2, steps_per_epoch=None, epochs=None):\n",
        "        super().__init__()\n",
        "        \n",
        "        self.min_lr = min_lr\n",
        "        self.max_lr = max_lr\n",
        "        self.total_iterations = steps_per_epoch * epochs\n",
        "        self.iteration = 0\n",
        "        self.history = {}\n",
        "        \n",
        "    def clr(self):\n",
        "        '''Calculate the learning rate.'''\n",
        "        x = self.iteration / self.total_iterations \n",
        "        return self.min_lr + (self.max_lr-self.min_lr) * x\n",
        "        \n",
        "    def on_train_begin(self, logs=None):\n",
        "        '''Initialize the learning rate to the minimum value at the start of training.'''\n",
        "        logs = logs or {}\n",
        "        K.set_value(self.model.optimizer.lr, self.min_lr)\n",
        "        \n",
        "    def on_batch_end(self, epoch, logs=None):\n",
        "        '''Record previous batch statistics and update the learning rate.'''\n",
        "        logs = logs or {}\n",
        "        self.iteration += 1\n",
        "\n",
        "        self.history.setdefault('lr', []).append(K.get_value(self.model.optimizer.lr))\n",
        "        self.history.setdefault('iterations', []).append(self.iteration)\n",
        "\n",
        "        for k, v in logs.items():\n",
        "            self.history.setdefault(k, []).append(v)\n",
        "            \n",
        "        K.set_value(self.model.optimizer.lr, self.clr())\n",
        " \n",
        "    def plot_lr(self):\n",
        "        '''Helper function to quickly inspect the learning rate schedule.'''\n",
        "        plt.plot(self.history['iterations'], self.history['lr'])\n",
        "        plt.yscale('log')\n",
        "        plt.xlabel('Iteration')\n",
        "        plt.ylabel('Learning rate')\n",
        "        plt.show()\n",
        "        \n",
        "    def plot_loss(self):\n",
        "        '''Helper function to quickly observe the learning rate experiment results.'''\n",
        "        plt.plot(self.history['lr'], self.history['loss'])\n",
        "        plt.xscale('log')\n",
        "        plt.xlabel('Learning rate')\n",
        "        plt.ylabel('Loss')\n",
        "        plt.show()"
      ],
      "outputs": [],
      "execution_count": 3,
      "metadata": {
        "id": "v3UUM1Fon3H-",
        "colab_type": "code",
        "colab": {}
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from tensorflow.keras.callbacks import Callback\n",
        "\n",
        "class WarmUpCosineDecayScheduler(Callback):\n",
        "    \"\"\"\n",
        "        Cosine decay with warmup learning rate scheduler\n",
        "    \"\"\"\n",
        "    def __init__(self,\n",
        "                 learning_rate_base,\n",
        "                 global_step_init=0,\n",
        "                 warmup_learning_rate=0.0,\n",
        "                 warmup_epoch=0,\n",
        "                 hold_base_rate_steps=0,\n",
        "                 learning_rate_final=None,\n",
        "                 stop_epoch=None,\n",
        "                 verbose=0):\n",
        "        \"\"\"Constructor for cosine decay with warmup learning rate scheduler.\n",
        "        Arguments:\n",
        "            learning_rate_base {float} -- base learning rate.\n",
        "            total_steps {int} -- total number of training steps.\n",
        "        Keyword Arguments:\n",
        "            global_step_init {int} -- initial global step, e.g. from previous checkpoint.\n",
        "            warmup_learning_rate {float} -- initial learning rate for warm up. (default: {0.0})\n",
        "            warmup_steps {int} -- number of warmup steps. (default: {0})\n",
        "            hold_base_rate_steps {int} -- Optional number of steps to hold base learning rate\n",
        "                                        before decaying. (default: {0})\n",
        "            verbose {int} -- 0: quiet, 1: update messages. (default: {0})\n",
        "        \"\"\"\n",
        "\n",
        "        super(WarmUpCosineDecayScheduler, self).__init__()\n",
        "        self.learning_rate_base = learning_rate_base\n",
        "        self.global_step = global_step_init\n",
        "        self.warmup_learning_rate = warmup_learning_rate\n",
        "        self.warmup_epoch = warmup_epoch\n",
        "        self.hold_base_rate_steps = hold_base_rate_steps\n",
        "        self.learning_rates = []\n",
        "        self.verbose = verbose\n",
        "        self.stop_epoch = stop_epoch\n",
        "        self.learning_rate_final = learning_rate_final\n",
        "        self.epoch = 0\n",
        "\n",
        "    def on_epoch_begin(self, epoch, logs=None):\n",
        "        self.epoch = epoch\n",
        "\n",
        "    def on_batch_end(self, batch, logs=None):\n",
        "        self.global_step = self.global_step + 1\n",
        "        lr = K.get_value(self.model.optimizer.lr)\n",
        "        self.learning_rates.append(lr)\n",
        "\n",
        "    def on_batch_begin(self, batch, logs=None):\n",
        "        total_steps = int(\n",
        "            self.params['epochs'] * self.params['samples'] / self.params['batch_size'])\n",
        "        warmup_steps = int(\n",
        "            self.warmup_epoch * self.params['samples']  / self.params['batch_size'])\n",
        "        lr = self.cosine_decay_with_warmup(\n",
        "            global_step=self.global_step,\n",
        "            learning_rate_base=self.learning_rate_base,\n",
        "            total_steps=total_steps,\n",
        "            warmup_learning_rate=self.warmup_learning_rate,\n",
        "            warmup_steps=warmup_steps,\n",
        "            hold_base_rate_steps=self.hold_base_rate_steps)\n",
        "        if self.stop_epoch is not None and self.stop_epoch > 0 and self.epoch >= self.stop_epoch:\n",
        "            if self.learning_rate_final is not None:\n",
        "                K.set_value(self.model.optimizer.lr, self.learning_rate_final)\n",
        "            else:\n",
        "                self.learning_rate_final = lr\n",
        "                K.set_value(self.model.optimizer.lr, self.learning_rate_final)\n",
        "        else:\n",
        "            K.set_value(self.model.optimizer.lr, lr)\n",
        "        if self.verbose > 0:\n",
        "            print('\\nBatch %05d: setting learning '\n",
        "                  'rate to %s.' % (self.global_step + 1, lr))\n",
        "\n",
        "    def cosine_decay_with_warmup(self, global_step,\n",
        "                                 learning_rate_base,\n",
        "                                 total_steps,\n",
        "                                 warmup_learning_rate=0.0,\n",
        "                                 warmup_steps=0,\n",
        "                                 hold_base_rate_steps=0):\n",
        "        \"\"\"Cosine decay schedule with warm up period.\n",
        "        Cosine annealing learning rate as described in\n",
        "            Loshchilov and Hutter, SGDR: Stochastic Gradient Descent with Warm Restarts.\n",
        "            ICLR 2017. https://arxiv.org/abs/1608.03983\n",
        "        In this schedule, the learning rate grows linearly from warmup_learning_rate\n",
        "        to learning_rate_base for warmup_steps, then transitions to a cosine decay\n",
        "        schedule.\n",
        "        Arguments:\n",
        "            global_step {int} -- global step.\n",
        "            learning_rate_base {float} -- base learning rate.\n",
        "            total_steps {int} -- total number of training steps.\n",
        "        Keyword Arguments:\n",
        "            warmup_learning_rate {float} -- initial learning rate for warm up. (default: {0.0})\n",
        "            warmup_steps {int} -- number of warmup steps. (default: {0})\n",
        "            hold_base_rate_steps {int} -- Optional number of steps to hold base learning rate\n",
        "                                        before decaying. (default: {0})\n",
        "        Returns:\n",
        "            a float representing learning rate.\n",
        "        Raises:\n",
        "            ValueError: if warmup_learning_rate is larger than learning_rate_base,\n",
        "            or if warmup_steps is larger than total_steps.\n",
        "        \"\"\"\n",
        "        if total_steps < warmup_steps:\n",
        "            raise ValueError('total_steps must be larger or equal to '\n",
        "                             'warmup_steps.')\n",
        "        learning_rate = 0.5 * learning_rate_base * (\n",
        "            1 + np.cos(\n",
        "                np.pi * (global_step - warmup_steps - hold_base_rate_steps) /\n",
        "                float(total_steps - warmup_steps - hold_base_rate_steps)\n",
        "                )\n",
        "            )\n",
        "        if hold_base_rate_steps > 0:\n",
        "            learning_rate = np.where(global_step > warmup_steps + hold_base_rate_steps,\n",
        "                                     learning_rate, learning_rate_base)\n",
        "        if warmup_steps > 0:\n",
        "            if learning_rate_base < warmup_learning_rate:\n",
        "                raise ValueError('learning_rate_base must be larger or equal to '\n",
        "                                 'warmup_learning_rate.')\n",
        "            slope = (learning_rate_base - warmup_learning_rate) / warmup_steps\n",
        "            warmup_rate = slope * global_step + warmup_learning_rate\n",
        "            learning_rate = np.where(global_step < warmup_steps, warmup_rate,\n",
        "                                     learning_rate)\n",
        "        return np.where(global_step > total_steps, 0.0, learning_rate)"
      ],
      "outputs": [],
      "execution_count": 4,
      "metadata": {
        "id": "FrozABbxn8CT",
        "colab_type": "code",
        "colab": {}
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from tensorflow.keras.callbacks import Callback\n",
        "\n",
        "class CyclicLR(Callback):\n",
        "    \"\"\"This callback implements a cyclical learning rate policy (CLR).\n",
        "    The method cycles the learning rate between two boundaries with\n",
        "    some constant frequency, as detailed in this paper (https://arxiv.org/abs/1506.01186).\n",
        "    The amplitude of the cycle can be scaled on a per-iteration or \n",
        "    per-cycle basis.\n",
        "    This class has three built-in policies, as put forth in the paper.\n",
        "    \"triangular\":\n",
        "        A basic triangular cycle w/ no amplitude scaling.\n",
        "    \"triangular2\":\n",
        "        A basic triangular cycle that scales initial amplitude by half each cycle.\n",
        "    \"exp_range\":\n",
        "        A cycle that scales initial amplitude by gamma**(cycle iterations) at each \n",
        "        cycle iteration.\n",
        "    For more detail, please see paper.\n",
        "    \n",
        "    # Example\n",
        "        ```python\n",
        "            clr = CyclicLR(base_lr=0.001, max_lr=0.006,\n",
        "                                step_size=2000., mode='triangular')\n",
        "            model.fit(X_train, Y_train, callbacks=[clr])\n",
        "        ```\n",
        "    \n",
        "    Class also supports custom scaling functions:\n",
        "        ```python\n",
        "            clr_fn = lambda x: 0.5*(1+np.sin(x*np.pi/2.))\n",
        "            clr = CyclicLR(base_lr=0.001, max_lr=0.006,\n",
        "                                step_size=2000., scale_fn=clr_fn,\n",
        "                                scale_mode='cycle')\n",
        "            model.fit(X_train, Y_train, callbacks=[clr])\n",
        "        ```    \n",
        "    # Arguments\n",
        "        base_lr: initial learning rate which is the\n",
        "            lower boundary in the cycle.\n",
        "        max_lr: upper boundary in the cycle. Functionally,\n",
        "            it defines the cycle amplitude (max_lr - base_lr).\n",
        "            The lr at any cycle is the sum of base_lr\n",
        "            and some scaling of the amplitude; therefore \n",
        "            max_lr may not actually be reached depending on\n",
        "            scaling function.\n",
        "        step_size: number of training iterations per\n",
        "            half cycle. Authors suggest setting step_size\n",
        "            2-8 x training iterations in epoch.\n",
        "        mode: one of {triangular, triangular2, exp_range}.\n",
        "            Default 'triangular'.\n",
        "            Values correspond to policies detailed above.\n",
        "            If scale_fn is not None, this argument is ignored.\n",
        "        gamma: constant in 'exp_range' scaling function:\n",
        "            gamma**(cycle iterations)\n",
        "        scale_fn: Custom scaling policy defined by a single\n",
        "            argument lambda function, where \n",
        "            0 <= scale_fn(x) <= 1 for all x >= 0.\n",
        "            mode paramater is ignored \n",
        "        scale_mode: {'cycle', 'iterations'}.\n",
        "            Defines whether scale_fn is evaluated on \n",
        "            cycle number or cycle iterations (training\n",
        "            iterations since start of cycle). Default is 'cycle'.\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, base_lr=0.001, max_lr=0.006, step_size=2000., mode='triangular',\n",
        "                 gamma=1., scale_fn=None, scale_mode='cycle'):\n",
        "        super(CyclicLR, self).__init__()\n",
        "\n",
        "        self.base_lr = base_lr\n",
        "        self.max_lr = max_lr\n",
        "        self.step_size = step_size\n",
        "        self.mode = mode\n",
        "        self.gamma = gamma\n",
        "        if scale_fn == None:\n",
        "            if self.mode == 'triangular':\n",
        "                self.scale_fn = lambda x: 1.\n",
        "                self.scale_mode = 'cycle'\n",
        "            elif self.mode == 'triangular2':\n",
        "                self.scale_fn = lambda x: 1/(2.**(x-1))\n",
        "                self.scale_mode = 'cycle'\n",
        "            elif self.mode == 'exp_range':\n",
        "                self.scale_fn = lambda x: gamma**(x)\n",
        "                self.scale_mode = 'iterations'\n",
        "        else:\n",
        "            self.scale_fn = scale_fn\n",
        "            self.scale_mode = scale_mode\n",
        "        self.clr_iterations = 0.\n",
        "        self.trn_iterations = 0.\n",
        "        self.history = {}\n",
        "\n",
        "        self._reset()\n",
        "\n",
        "    def _reset(self, new_base_lr=None, new_max_lr=None,\n",
        "               new_step_size=None):\n",
        "        \"\"\"Resets cycle iterations.\n",
        "        Optional boundary/step size adjustment.\n",
        "        \"\"\"\n",
        "        if new_base_lr != None:\n",
        "            self.base_lr = new_base_lr\n",
        "        if new_max_lr != None:\n",
        "            self.max_lr = new_max_lr\n",
        "        if new_step_size != None:\n",
        "            self.step_size = new_step_size\n",
        "        self.clr_iterations = 0.\n",
        "        \n",
        "    def clr(self):\n",
        "        cycle = np.floor(1+self.clr_iterations/(2*self.step_size))\n",
        "        x = np.abs(self.clr_iterations/self.step_size - 2*cycle + 1)\n",
        "        if self.scale_mode == 'cycle':\n",
        "            return self.base_lr + (self.max_lr-self.base_lr)*np.maximum(0, (1-x))*self.scale_fn(cycle)\n",
        "        else:\n",
        "            return self.base_lr + (self.max_lr-self.base_lr)*np.maximum(0, (1-x))*self.scale_fn(self.clr_iterations)\n",
        "        \n",
        "    def on_train_begin(self, logs={}):\n",
        "        logs = logs or {}\n",
        "\n",
        "        if self.clr_iterations == 0:\n",
        "            K.set_value(self.model.optimizer.lr, self.base_lr)\n",
        "        else:\n",
        "            K.set_value(self.model.optimizer.lr, self.clr())        \n",
        "            \n",
        "    def on_batch_end(self, epoch, logs=None):\n",
        "        \n",
        "        logs = logs or {}\n",
        "        self.trn_iterations += 1\n",
        "        self.clr_iterations += 1\n",
        "\n",
        "        self.history.setdefault('lr', []).append(K.get_value(self.model.optimizer.lr))\n",
        "        self.history.setdefault('iterations', []).append(self.trn_iterations)\n",
        "\n",
        "        for k, v in logs.items():\n",
        "            self.history.setdefault(k, []).append(v)\n",
        "        \n",
        "        K.set_value(self.model.optimizer.lr, self.clr())"
      ],
      "outputs": [],
      "execution_count": 5,
      "metadata": {
        "id": "BbgcPRgvoCh1",
        "colab_type": "code",
        "colab": {}
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def step_decay_schedule(initial_lr=1e-5, decay_factor=0.75, step_size=10):\n",
        "    '''\n",
        "    Wrapper function to create a LearningRateScheduler with step decay schedule.\n",
        "    '''\n",
        "    def schedule(epoch):\n",
        "        return initial_lr * (decay_factor ** np.floor(epoch/step_size))\n",
        "    return tf.keras.callbacks.LearningRateScheduler(schedule, verbose=1)"
      ],
      "outputs": [],
      "execution_count": 6,
      "metadata": {
        "id": "kVqbWvpQoGhV",
        "colab_type": "code",
        "colab": {}
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Mish(tf.keras.layers.Layer):\n",
        "\n",
        "    def __init__(self, **kwargs):\n",
        "        super(Mish, self).__init__(**kwargs)\n",
        "        self.supports_masking = True\n",
        "\n",
        "    def call(self, inputs):\n",
        "        return inputs * K.tanh(K.softplus(inputs))\n",
        "\n",
        "    def get_config(self):\n",
        "        base_config = super(Mish, self).get_config()\n",
        "        return dict(list(base_config.items()) + list(config.items()))\n",
        "\n",
        "    def compute_output_shape(self, input_shape):\n",
        "        return input_shape\n",
        "def mish(x):\n",
        "\treturn tf.keras.layers.Lambda(lambda x: x*K.tanh(K.softplus(x)))(x)\n",
        " \n",
        "from tensorflow.keras.utils import get_custom_objects\n",
        "from tensorflow.keras.layers import Activation\n",
        "get_custom_objects().update({'mish': Activation(mish)})"
      ],
      "outputs": [],
      "execution_count": 11,
      "metadata": {
        "id": "3JPfg_2_5UIT",
        "colab_type": "code",
        "colab": {}
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def r2_keras(y_true, y_pred):\n",
        "    K = tf.keras.backend\n",
        "    SS_res =  K.sum(K.square( y_true-y_pred ))\n",
        "    SS_tot = K.sum(K.square( y_true - K.mean(y_true) ) )\n",
        "    return ( 1 - SS_res/(SS_tot + K.epsilon()) )"
      ],
      "outputs": [],
      "execution_count": 33,
      "metadata": {
        "id": "4Tmgii6UOWab",
        "colab_type": "code",
        "colab": {}
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def kaeri_metric(y_true,  y_pred):\n",
        "\n",
        "    '''\n",
        "        y_true: dataframe with true values ​​of X,Y,M,V\n",
        "        y_pred: dataframe with pred values ​​of X,Y,M,V\n",
        "\n",
        "        return: KAERI metric\n",
        "    '''\n",
        "    \n",
        "    _t1, _p1 = np.array(y_true)[:,:2], np.array(y_pred)[:,:2]\n",
        "    E1 = np.mean(np.sum(np.square(_t1-_p1), axis=1) / 2e+04)\n",
        "      \n",
        "    _t2, _p2 = np.array(y_true)[:,2:], np.array(y_pred)[:,2:]\n",
        "    E2 = np.mean(np.sum(np.square((_t2-_p2) / (_t2 + 1e-06)), axis=1))\n",
        "\n",
        "    return 0.5*E1 + 0.5*E2\n",
        "    # return  0.5*E1(y_true, y_pred ) + 0.5*E2( y_true, y_pred )\n"
      ],
      "outputs": [],
      "execution_count": 7,
      "metadata": {
        "id": "-wulbMIDKIoE",
        "colab_type": "code",
        "colab": {}
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def calc_ewm(s, windows=[10, 50]):\n",
        "    '''\n",
        "    Calculates exponential weighted functions\n",
        "    '''\n",
        "    ewm = pd.DataFrame()\n",
        "    for w in windows:\n",
        "        ewm['ewm_mean_' + str(w)] = s.ewm(span=w, min_periods=1).mean()\n",
        "        ewm['ewm_std_' + str(w)] = s.ewm(span=w, min_periods=1).std()\n",
        "    # add zeros when na values (std)\n",
        "    ewm = ewm.fillna(value=0)       \n",
        "    return ewm\n",
        "\n",
        "\n",
        "def preprocess_data(df, cols=[\"S1\",\"S2\",'S3','S4']):\n",
        "\n",
        "    sensor_cols = cols # ['S1','S2','S3','S4']\n",
        "\n",
        "    df2 = pd.DataFrame(index=df.groupby(['id'])['id'].apply(pd.Series).unique())\n",
        "\n",
        "    df2['Time'] = df['Time']\n",
        "\n",
        "    for col in sensor_cols:\n",
        "        df2[col+'_mean'] = df.groupby(['id'])[col].apply(lambda x: np.mean(x))\n",
        "        df2[col+'_max'] = df.groupby(['id'])[col].apply(lambda x: np.max(x))\n",
        "        df2[col+'_min'] = df.groupby(['id'])[col].apply(lambda x: np.min(x))\n",
        "        df2[col+'_std'] = df.groupby(['id'])[col].apply(lambda x: np.std(x))\n",
        "        df2[col+'_median'] = df.groupby(['id'])[col].apply(lambda x: np.median(x))\n",
        "\n",
        "        df2[col+'_p10'] = df.groupby(['id'])[col].apply(lambda x: np.percentile(x, 10))\n",
        "        df2[col+'_p25'] = df.groupby(['id'])[col].apply(lambda x: np.percentile(x, 25))\n",
        "        df2[col+'_p75'] = df.groupby(['id'])[col].apply(lambda x: np.percentile(x, 75))\n",
        "        df2[col+'_p90'] = df.groupby(['id'])[col].apply(lambda x: np.percentile(x, 90))\n",
        "        df2[col+'_skew'] = df.groupby(['id'])[col].apply(lambda x: pd.Series(x).skew())\n",
        "        # df2[col+'_kurtosis'] = df.groupby([col])[col].apply(lambda x: pd.Series(x).kurtosis())\n",
        "\n",
        "\n",
        "        min_max = (df2[col+'_mean'] - df2[col+'_min']) / (df2[col+'_max'] - df2[col+'_min'])\n",
        "        df2[col+'_norm'] = min_max * (np.floor(df2[col+'_max']) - np.ceil(df2[col+'_min']))\n",
        "        df2[col+'_mean_abs_chg'] = df.groupby(['id'])[col].apply(lambda x: np.mean(np.abs(np.diff(x))))\n",
        "        df2[col+'_abs_max'] = df.groupby(['id'])[col].apply(lambda x: np.max(np.abs(x)))\n",
        "        df2[col+'_abs_min'] = df.groupby(['id'])[col].apply(lambda x: np.min(np.abs(x)))\n",
        "        df2[col+'_range'] = df2[col+'_max'] - df2[col+'_min']\n",
        "        df2[col+'_maxtomin'] = df2[col+'_max'] / df2[col+'_min']\n",
        "        df2[col+'_abs_avg'] = (df2[col+'_abs_min'] + df2[col+'_abs_max']) / 2\n",
        "\n",
        "        # ewm = calc_ewm(df[col])\n",
        "        # ewm.columns = [col+'_'+n for n in ewm.columns]\n",
        "        # df2 = pd.concat([df2, ewm], axis=1)\n",
        "\n",
        "    return df2"
      ],
      "outputs": [],
      "execution_count": 8,
      "metadata": {
        "id": "gEITjBiPCPX7",
        "colab_type": "code",
        "colab": {}
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def seed_everything(seed):\n",
        "    \n",
        "    # rn.seed(seed)\n",
        "    np.random.seed(seed)\n",
        "    os.environ['PYTHONHASHSEED'] = str(seed)\n",
        "    tf.random.set_seed(seed)\n",
        "\n"
      ],
      "outputs": [],
      "execution_count": 13,
      "metadata": {
        "id": "G-jnJH1R3IOT",
        "colab_type": "code",
        "colab": {}
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def batching(df : pd.DataFrame,\n",
        "             batch_size : int) -> pd.DataFrame :\n",
        "    \n",
        "    df['group'] = df.groupby(df.index//batch_size, sort=False)['signal'].agg(['ngroup']).values\n",
        "    df['group'] = df['group'].astype(np.uint16)\n",
        "        \n",
        "    return df\n",
        "\n",
        "\n",
        "\n",
        "def lag_with_pct_change(df : pd.DataFrame,\n",
        "                        shift_sizes,    # : Optional[List]=[1, 2],\n",
        "                        add_pct_change,  #: Optional[bool]=False,\n",
        "                        add_pct_change_lag, # : Optional[bool]=False) -> pd.DataFrame: \n",
        "):\n",
        "    \n",
        "    for shift_size in shift_sizes:    \n",
        "        df['signal_shift_pos_'+str(shift_size)] = df.groupby('group')['signal'].shift(shift_size).fillna(0)\n",
        "        df['signal_shift_neg_'+str(shift_size)] = df.groupby('group')['signal'].shift(-1*shift_size).fillna(0)\n",
        "\n",
        "    if add_pct_change:\n",
        "        df['pct_change'] = df['signal'].pct_change()\n",
        "        if add_pct_change_lag:\n",
        "            for shift_size in shift_sizes:    \n",
        "                df['pct_change_shift_pos_'+str(shift_size)] = df.groupby('group')['pct_change'].shift(shift_size).fillna(0)\n",
        "                df['pct_change_shift_neg_'+str(shift_size)] = df.groupby('group')['pct_change'].shift(-1*shift_size).fillna(0)\n",
        "    return df\n",
        "\n",
        "\n",
        "\n",
        "def run_feat_enginnering(df : pd.DataFrame,\n",
        "                         create_all_data_feats : bool,\n",
        "                         batch_size : int) -> pd.DataFrame:\n",
        "    \n",
        "    df = batching(df, batch_size=batch_size)\n",
        "    if create_all_data_feats:\n",
        "        df = lag_with_pct_change(df, [1, 2, 3],  add_pct_change=False, add_pct_change_lag=False)\n",
        "    df['signal_2'] = df['signal'] ** 2\n",
        "    return df"
      ],
      "outputs": [],
      "execution_count": 10,
      "metadata": {
        "id": "hJkYuarN3UoR",
        "colab_type": "code",
        "colab": {}
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Load data"
      ],
      "metadata": {
        "id": "J6j6dfmwlNd2",
        "colab_type": "text"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "SEED = 26\n",
        "seed_everything(SEED)\n",
        "\n",
        "train_df, targets, test_df, subm = read_data()"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Shape of train: (1050000, 6)\n",
            "Shape of solution: (262500, 6)\n",
            "Shape of submision: (700, 5)\n"
          ]
        }
      ],
      "execution_count": 17,
      "metadata": {
        "id": "_TgRKw5Ik14-",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 67
        },
        "outputId": "50180f8c-5181-4d67-b103-ab25215d1291"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(train_df.head())\n",
        "print(test_df.head())\n",
        "print(subm.head())"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "   id      Time   S1   S2   S3   S4\n",
            "0   0  0.000000  0.0  0.0  0.0  0.0\n",
            "1   0  0.000004  0.0  0.0  0.0  0.0\n",
            "2   0  0.000008  0.0  0.0  0.0  0.0\n",
            "3   0  0.000012  0.0  0.0  0.0  0.0\n",
            "4   0  0.000016  0.0  0.0  0.0  0.0\n",
            "     id      Time   S1   S2   S3   S4\n",
            "0  2800  0.000000  0.0  0.0  0.0  0.0\n",
            "1  2800  0.000004  0.0  0.0  0.0  0.0\n",
            "2  2800  0.000008  0.0  0.0  0.0  0.0\n",
            "3  2800  0.000012  0.0  0.0  0.0  0.0\n",
            "4  2800  0.000016  0.0  0.0  0.0  0.0\n",
            "     id           X           Y           M         V\n",
            "0  2800 -251.151642  -33.210499  115.361504  0.415139\n",
            "1  2801  306.643158 -297.179871   95.554611  0.416388\n",
            "2  2802 -227.187210  130.209641   28.086653  0.354145\n",
            "3  2803  155.305527  275.610199   26.912380  0.370306\n",
            "4  2804 -155.184830  179.915222  135.617783  0.422606\n"
          ]
        }
      ],
      "execution_count": 69,
      "metadata": {
        "id": "40XYK2UHlLS7",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 319
        },
        "outputId": "2e508e96-1bd0-448e-8c41-c1709b2a1e03"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "train_df.isnull().sum().sum(), test_df.isnull().sum().sum()"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 19,
          "data": {
            "text/plain": [
              "(0, 0)"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ],
      "execution_count": 19,
      "metadata": {
        "id": "f9xbKlNH4Bdu",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "ffac96a5-9444-443b-de38-7626b1b43e87"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# EDA"
      ],
      "metadata": {
        "id": "3_v__qXGlPXv",
        "colab_type": "text"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Inputs \n",
        "plt.figure()\n",
        "sns.distplot(train_df.S1, label='train') \n",
        "sns.distplot(test_df.S1, label='test')\n",
        "\n",
        "plt.figure()\n",
        "sns.distplot(train_df.S2, label='train')\n",
        "sns.distplot(test_df.S2, label='test')\n",
        "\n",
        "plt.figure()\n",
        "sns.distplot(train_df.S3, label='train') \n",
        "sns.distplot(test_df.S3, label='test')\n",
        "\n",
        "plt.figure()\n",
        "sns.distplot(train_df.S4, label='train') \n",
        "sns.distplot(test_df.S4, label='test')"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 11,
          "data": {
            "text/plain": [
              "<matplotlib.axes._subplots.AxesSubplot at 0x7f8254581c50>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": [
              "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\n"
            ],
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": [
              "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\n"
            ],
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": [
              "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\n"
            ],
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": [
              "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\n"
            ],
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ],
      "execution_count": null,
      "metadata": {
        "id": "YjnIAdet2cew",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "a5bf16db-aa6f-4d02-8521-65cfd6df6613"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Targets\n",
        "plt.figure()\n",
        "sns.distplot(targets.X, label='train X') \n",
        " \n",
        "plt.figure()\n",
        "sns.distplot(targets.Y, label='train Y') \n",
        "\n",
        "plt.figure()\n",
        "sns.distplot(targets.M, label='train M') \n",
        "\n",
        "plt.figure()\n",
        "sns.distplot(targets.V, label='train V') "
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 44,
          "data": {
            "text/plain": [
              "<matplotlib.axes._subplots.AxesSubplot at 0x7f988597ca20>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": [
              "iVBORw0KGgoAAAANSUhEUgAAAY8AAAEGCAYAAACdJRn3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nO3deXxc1Znn/89TVVotW7Jsyatsy1heZAwGO4YkhMVmMYTgLBBM0gnpkNCdwPR0Z6Yz0P0auoff+PcLya+HJBMgQwKBpCHGTTaHOCEEE5YAtsViG29Y3uVNsizLtqxdz/xR11AWWqpsWVUlfd+vV71077nnnvscl1yP6p577zF3R0REJBGhZAcgIiLpR8lDREQSpuQhIiIJU/IQEZGEKXmIiEjCIskO4GwaOXKkT5o0KdlhiIiklTfeeOOQuxf1VGdAJ49JkyZRUVGR7DBERNKKme3qrY5OW4mISMKUPEREJGFKHiIikjAlDxERSZiSh4iIJEzJQ0REEqbkISIiCVPyEBGRhCl5iIhIwgb0HeaD0ZOrdvfr8T530YTT3vd0Yz3dY/b38ZIhGX1Ml/fxTKTT70B/0TcPERFJmJKHiIgkTMlDREQSpuQhIiIJU/IQEZGEKXmIiEjC4koeZrbQzLaYWaWZ3dXF9iwzeyrYvsrMJsVsuzso32Jm1wRlJWb2gpltNLMNZvafY+oXmtlzZrY1+Dk8KDcz+37Q1jozu/BMOy8iIqen1+RhZmHgAeBaoBy4xczKO1W7Dahz9ynA/cB9wb7lwGJgJrAQeDBorw34L+5eDlwM3BHT5l3A8+5eBjwfrBMcvyx43Q48dFo9FhGRMxbPN495QKW7b3f3FmApsKhTnUXA48Hy08ACM7OgfKm7N7v7DqASmOfu+939TQB3PwZsAsZ10dbjwCdjyn/qUa8DBWY2JsH+iohIH4gneYwD9sSsV/H+B/0H6rh7G1APjIhn3+AU1wXAqqBolLvvD5YPAKMSiAMzu93MKsysoqampvfeiYhIwpI6YG5mecAvgL9396Odt7u7A55Im+7+sLvPdfe5RUVFfRSpiIjEiid57AVKYtbHB2Vd1jGzCJAP1Pa0r5llEE0cT7j7L2PqHDx5Oir4WZ1AHCIi0g/iSR5rgDIzKzWzTKID4Ms71VkO3Bos3wisDL41LAcWB1djlRId7F4djIc8Amxy9//VQ1u3Ar+JKf9icNXVxUB9zOktERHpR70+Vdfd28zsTuBZIAw86u4bzOxeoMLdlxNNBD8zs0rgMNEEQ1BvGbCR6BVWd7h7u5ldAnwBWG9mbweH+id3XwF8C1hmZrcBu4DPBttXANcRHXQ/Afx1H/RfREROQ1yPZA8+1Fd0KrsnZrkJuKmbfZcASzqVvQJYN/VrgQVdlDtwRzzxiojI2aU7zEVEJGFKHiIikjAlDxERSZiSh4iIJEzJQ0REEqbkISIiCVPyEBGRhMV1n4eInJ4nV+0+rf0+d9GEPo5EpG/pm4eIiCRMyUNERBKm5CEiIglT8hARkYQpeYiISMKUPEREJGFKHiIikjAlDxERSVhcycPMFprZFjOrNLO7utieZWZPBdtXmdmkmG13B+VbzOyamPJHzazazN7p1NZTZvZ28Np5cqZBM5tkZo0x2354up0WEZEz0+sd5mYWBh4ArgKqgDVmttzdN8ZUuw2oc/cpZrYYuA+42czKiU5JOxMYC/zJzKa6ezvwGPAD4Kexx3P3m2OO/W9Afczmbe4+O/FuiohIX4rnm8c8oNLdt7t7C7AUWNSpziLg8WD5aWCBmVlQvtTdm919B9H5x+cBuPtLROc771Kw/2eBnyfQHxER6QfxJI9xwJ6Y9aqgrMs67t5G9NvCiDj37c7HgIPuvjWmrNTM3jKzF83sY13tZGa3m1mFmVXU1NTEeSgREUlEKg+Y38Kp3zr2AxPc/QLgG8CTZjas807u/rC7z3X3uUVFRf0UqojI4BJP8tgLlMSsjw/KuqxjZhEgH6iNc98PCNr4NPDUybLg1FdtsPwGsA2YGkf8IiLSx+JJHmuAMjMrNbNMogPgyzvVWQ7cGizfCKx0dw/KFwdXY5UCZcDqOI55JbDZ3atOFphZUTB4j5lNDtraHkdbIiLSx3q92srd28zsTuBZIAw86u4bzOxeoMLdlwOPAD8zs0qig+CLg303mNkyYCPQBtwRXGmFmf0cuBwYaWZVwL+4+yPBYRfzwYHyS4F7zawV6AD+1t27HXAXEZGzJ67JoNx9BbCiU9k9MctNwE3d7LsEWNJF+S09HO9LXZT9AvhFPPGKiMjZlcoD5iIikqKUPEREJGFKHiIikjAlDxERSZiSh4iIJEzJQ0REEqbkISIiCVPyEBGRhCl5iIhIwpQ8REQkYUoeIiKSMCUPERFJmJKHiIgkTMlDREQSpuQhIiIJiyt5mNlCM9tiZpVmdlcX27PM7Klg+yozmxSz7e6gfIuZXRNT/qiZVZvZO53a+lcz22tmbwev63prS0RE+levySOY+vUB4FqgHLjFzMo7VbsNqHP3KcD9wH3BvuVEZwWcCSwEHjw5lSzwWFDWlfvdfXbwWhFHWyIi0o/i+eYxD6h09+3u3gIsBRZ1qrMIeDxYfhpYYGYWlC9192Z33wFUBu3h7i8RnbI2Xt22JSIi/Sue5DEO2BOzXhWUdVnH3duAemBEnPt25U4zWxec2hqeQBwiItIPUnHA/CHgHGA2sB/4t0R2NrPbzazCzCpqamrORnwiIoNePMljL1ASsz4+KOuyjplFgHygNs59T+HuB9293d07gB/x/qmpuNpy94fdfa67zy0qKuqlayIicjriSR5rgDIzKzWzTKKD1ss71VkO3Bos3wisdHcPyhcHV2OVAmXA6p4OZmZjYlY/BZy8GivhtkRE5OyI9FbB3dvM7E7gWSAMPOruG8zsXqDC3ZcDjwA/M7NKooPgi4N9N5jZMmAj0Abc4e7tAGb2c+ByYKSZVQH/4u6PAN82s9mAAzuBv+mtLRER6V+9Jg+A4HLZFZ3K7olZbgJu6mbfJcCSLspv6ab+F3qIo8u2RESkf6XigLmIiKQ4JQ8REUmYkoeIiCRMyUNERBKm5CEiIglT8hARkYQpeYiISMKUPEREJGFKHiIikjAlDxERSZiSh4iIJEzJQ0REEqbkISIiCVPyEBGRhCl5iIhIwpQ8REQkYXElDzNbaGZbzKzSzO7qYnuWmT0VbF9lZpNitt0dlG8xs2tiyh81s2oze6dTW98xs81mts7MfmVmBUH5JDNrNLO3g9cPT7fTIiJyZnpNHmYWBh4ArgXKgVvMrLxTtduAOnefAtwP3BfsW050StqZwELgwaA9gMeCss6eA8519/OAd4G7Y7Ztc/fZwetv4+uiiIj0tXi+ecwDKt19u7u3AEuBRZ3qLAIeD5afBhaYmQXlS9292d13AJVBe7j7S0TnOz+Fu//R3duC1deB8Qn2SUREzrJ4ksc4YE/MelVQ1mWd4IO/HhgR5749+TLw+5j1UjN7y8xeNLOPdbWDmd1uZhVmVlFTU5PAoUREJF4pO2BuZv8MtAFPBEX7gQnufgHwDeBJMxvWeT93f9jd57r73KKiov4LWERkEIkneewFSmLWxwdlXdYxswiQD9TGue8HmNmXgOuBz7u7AwSnvmqD5TeAbcDUOOIXEZE+Fk/yWAOUmVmpmWUSHQBf3qnOcuDWYPlGYGXwob8cWBxcjVUKlAGrezqYmS0Evgnc4O4nYsqLTg62m9nkoK3tccQvIiJ9LNJbBXdvM7M7gWeBMPCou28ws3uBCndfDjwC/MzMKokOgi8O9t1gZsuAjURPQd3h7u0AZvZz4HJgpJlVAf/i7o8APwCygOeiY+68HlxZdSlwr5m1Ah3A37r7BwbcRUTk7Os1eQC4+wpgRaeye2KWm4Cbutl3CbCki/Jbuqk/pZvyXwC/iCdeERE5u1J2wFxERFKXkoeIiCRMyUNERBKm5CEiIglT8hARkYTFdbWVDF5tHR0cqG+i5lgzh463cLSxlRMtbTS2duA4v3qripzMCAU5GQzPzSA/N5OCnAwKcjMYnptJQW4GBbmZ5OdkEAkbYTOa2zo43tTGviONNLW109zawYmWdk60tNHQ3B60305bu9Pa0YEB4ZCREQ4xJDPCgfpGCodkUpiXxci8TIqHZlM0NIth2RGCy7ulj7W1d1B3ojX4PYh9tbBmx2FOtLTT7k5Hh5MRDpEZCZF18pURJjczzJDMCLlZ0Z85mWFqjzeTlRHG3enogBOtbdQ1tHLkRAtHGlupO9HCkROt1De2UtcQLatvbOXg0SYAMsKhaLtZEUYMyWRkXhZj8rMZmp2R5H+twUHJQ07R1tHB7toTbK0+zvaa4+yvb6KtwwEIGQzNziA3M0x2RpiQGZFQiPrGVnbVNnDkRCtHm1qJPhPg9ITNyM0Kk5MRJiMcIhIyHGhu66C5rZUTzQ2s2XW4y2NkRUIUDc16L8acjDA5wc9I2NhVe4KQQciMcMjIzohuy8/JYEReJiOGZJEZGXhfxt2dI42t1B5voe5EC02t7bS0ddDS3kFLWwet7c7qHbW0dTjtHU5ru9Pc1h790A4+wI81tXXZdlYkRE5mmNyMMOGQEQoZzc1tNDe009wWbb+lrYOufiW+8+yWuOLPzghRkBP9Q2RYTgbhkIFDc2s7dQ0tHG9uo7mt4736BbkZTCzMpax4KFNG5TFMyeSsUPIQ2jucyurjrN97hI37j9LU2kHIYPzwXD48eQTjC3MZNSyLwiGZREKnfrh+7qIJH2jraGNrzF+O0Q+fo42t7304ZWeEycuK8NbuOrIywmRFQuRmRhiSGSYzEur128PNHyrhyIkWDje0UHO8mZpjzVQfbabmeDPVR5s43txOY2sbJ1raqG2Ifli2dXRwtLGNjuCv47YOP+UDB6LJcXR+NhMKhzBt1FDOKRpCJJyeyeTQsWY2HTjKjkMN7D58ghMt7R+oEwkZmZEQGeEQtQ3NhENGJBT9gyAzEqJwSCbnFOWRH3yTLAz+uh8ZfOMrGppFXlaEn6/e00UE7+twp7GlnYaWNk40R382trQze0IBTa3tGNGkk5MRZnjwTTX2m2t2RviU9p5ctfuUdXfneHMbNceb2VfXyO66RiprGlhbVQ/AhMJcZo3LZ9b4fCWSPqTkMYgdb25jzc7DrN5xmPrGVrIzQpSPyad8zFAmF+V94D9tPMIhY/iQTIYPyaSUIT3W7fzhncgxRuRlMSIvi7JRQ+Per/OHToc7TS3t0b/KG1o4UN/I7sMneHNXHa9vryUzEqJ8zDBKRw7h4smFKX9KrPpYEy++W8Obu+uoOdYMQFFeFjPGDGP88BxG5mVRmJtJTpCkQzH96fxHQF8KmTEkK8KQrAjEvF19dUwzY2h2BkOzM5g8Mg+IvrcH6pt49+Ax1u+t53fr9/P7d/ZTPjafiycXUjpiSMq/n6lOyWMQampt55XKQ7yy9RAt7R1MKcrj47PGMH300LT9S/t0hMzIzYqQmxVhbEEOs8blA9Hz+9tqGtiwr5539tVzy49ep3TkED47t4Qb54ynaGhWkiN/X3uH89K7NSxds5vnN1XT1uFMHJHL9eeNoXzMMApyM5MdYlKEzBhbkMPYghwun1ZMzbFmKnYepmJXHe/srWfyyCFcM3M0JYW5yQ41bSl5DDIb9x3lV29V0dDSzrnj8rlyejHFw7KTHVZKiYRDTBs9lGmjh3L9eWMZmh3hqTV7uO8Pm/m3P25h/vRibv5QCZdNLUpast1de4Kn39jD029Usa++iRFDMrntklJyMyMpldxSRdHQLK6dNYYry0exZudhXthSw0MvbuPCCcO5/rwxp/Ute7BT8hgkWto6+N36/azZeZixBdnc+pFJjB+uv7p6kxkJ8Zk54/nMnPFUVh9nWcUefvlmFX/ceJCioVl85sLx3DR3POcU5Z31WBpb2vnDhv0sW1PFa9trMYNLy4r479eXs2DGKDIjoQ+cmpNTZYRDfOSckcyZOJwXt9Tw4rs17Dh0nJvnljBhRM+nWeVUSh6DQGNLO4+/tpM9h09waVkRV5YXf2DgW3o3pTiPf7puBv94zTRe2FzNsoo9/Ojl7fzwxW1MGzWUBTOK+VhZEeeX5JObeeb/tdyd7YcaWL3jMCs3V/PK1kM0trYzoTCX/3r1VD594XjGFuT0Qc8Gn6xImKtnjmba6KHR9/GVHdzyoQmUj/3A/HLSDSWPAa6huY2f/GUHB482c8u8CZwbnNeX05cRDnH1zNFcPXM01UebWL52H3/adJD/89J2HvzzNsIhY+qooUwpzqOhuY38nAzysiLkZobfu0w4HIre89LuTmt7B02tHRxvbuN4U3Tw/pl1+9i0/yh1J1oBGJufzY1zxnPtrNFcXDqCUEiDvX1h4ogh3HlFGY+9uoMnV+/ipjklnF9SkOyw0oKSxwDW0tbBo3/ZQc2xZv7q4olMGx3/lUkSn+Jh2XzlY5P5yscmU9/Yypu76nhzdx1rq+p5a3cde+sau7zHoSfZGSGmjR7GVeWjuHDCcOZMHM6U4jxdHXSW5GSG+fJHS3n8tV0sq9hDJGzMHKs/snoTV/IIZvf7HtHJoH7s7t/qtD0L+Ckwh+j0sze7+85g293AbUA78Hfu/mxQ/ijRqWar3f3cmLYKgaeAScBO4LPuXmfR/znfA64DTgBfcvc3T6vXg4B79O7vA/VNfPHDk5Q4+kF+TgZXTC/miunF75X99NWdHGtuo6E5etd8R3CvS7tDe0cHITMywyEyM0LkZUbIy46QkxHm8xdPTGJPBp+sjDBf+sgkfvzKdp5+o+q9pxZI93o98R1M/foAcC1QDtxiZuWdqt0G1AUTOd0P3BfsW050VsGZwELgwZNTyQKPBWWd3QU87+5lwPPBOsHxy4LX7cBD8XVxcHptey1rq+q5qnyUEkcSRcIhhudmMn549I7naaOHUT42n1nj8pldMpzzxhcwfcwwJo/Mo3hYNrmZesRKsmRGQnxu3gTCIeOJVbtobvvgjZXyvnhGTecBle6+3d1bgKXAok51FgGPB8tPAwuCbwqLgKXu3uzuO4DKoD3c/SWiU9Z2FtvW48AnY8p/6lGvAwVmNiaeTg42e+saWbF+PzNGD+XSqUXJDkckbRTkZrL4QxOoOdbMb9fuS3Y4KS2e5DEOiH3+QFVQ1mUdd28D6oERce7b2Sh33x8sHwBGJRDHoNfhzm/W7mVIZoQb55ScchexiPRuSnEel00t4s3dR9hxqCHZ4aSslL5e090dEhtvNLPbzazCzCpqamrOUmSp641ddVTVNbLw3NHkZOrGJ5HTcfm0YgpyM1i+di/tHWfwpM8BLJ7ksRcoiVkfH5R1WcfMIkA+0YHzePbt7ODJ01HBz+oE4sDdH3b3ue4+t6hocJ2yqWto4dkNB5g0IpfZutxQ5LRlRkJcP2sMB4828/r22mSHk5LiSR5rgDIzKzWzTKID4Ms71VkO3Bos3wisDL41LAcWm1mWmZUSHexe3cvxYtu6FfhNTPkXLepioD7m9JYA3/3TuzS1tnPD+eM06CpyhmaMGcbUUXn8adNBao83JzuclNNr8gjGMO4EngU2AcvcfYOZ3WtmNwTVHgFGmFkl8A2CK6TcfQOwDNgI/AG4w93bAczs58BrwDQzqzKz24K2vgVcZWZbgSuDdYAVwHaig+4/Ar5+Rj0fYKqPNvHz1XuYM3E4o/P1rCqRM2VmXHfuGFraOnjs1Z3JDiflxHWfh7uvIPrhHVt2T8xyE3BTN/suAZZ0UX5LN/VrgQVdlDtwRzzxDkY/enk77e5cNrW498oiEpfiYdmUjx3GY6/u5KuXTtZ8IDFSesBc4lPX0MITq3Zzw/ljKRwyOB/BLXK2XD6tmGNNbfzstV3JDiWlKHkMAD95dScnWtr52uXnJDsUkQFnXEEOl00t4tFXdtDYxYyMg5WSR5o70dLGY3/ZwdXlo5iawKx6IhK/O66YQm1DC8sqep5ydzBR8khzz6zdz9GmNr566eRkhyIyYM0rLeT8kgKeWLWL6PCrKHmkuSdX76asOI+5E4cnOxSRAe1z80p49+Bx3txdl+xQUoKSRxrbuO8ob+85wuJ5E3Rfh8hZdv15YxmSGebJVTp1BUoeaW3pmt1kRkJ8+gI94kvkbBuSFWHRBeP43fp91De2JjucpFPySFONLe386q29XHfuaIbr8lyRfvG5eRNoau3gN2/39pSlgU/JI02tWL+fY01tLJ43IdmhiAwa547L59xxw3hy1e5kh5J0Sh5p6tdv76WkMIeLSguTHYrIoHLTnBI2HzjGlgPHkh1KUil5pKFDx5t5dVstN5w/VgPlIv3sulljCBk8s25wTxal5JGGfv/OAdo7nE+cPzbZoYgMOkVDs/jIOSNZvnbfoL7nQ8kjDf327X2UFecxTXeUiyTFJ84fw67aE6zfW5/sUJJGySPN7K9vZPXOwzplJZJEC2eOISNsg3qecyWPNPO7ddH5r3TKSiR58nMzuGxqEc+s20/HIJ2mVskjzfx27T7OG5/PpJFDkh2KyKD2ifPHsr++iYpdg/NxJXElDzNbaGZbzKzSzO7qYnuWmT0VbF9lZpNitt0dlG8xs2t6a9PMXjazt4PXPjP7dVB+uZnVx2y7h0Hm4NEm1lbVc83M0ckORWTQWzBjFJnhEM9uOJDsUJKi1+RhZmHgAeBaoBy4xczKO1W7Dahz9ynA/cB9wb7lROc8nwksBB40s3BPbbr7x9x9trvPJjpN7S9jjvPyyW3ufu9p9zpNvbC5GoArZ4xKciQikpcV4aNTRvDHjQcG5VVX8XzzmAdUuvt2d28BlgKLOtVZBDweLD8NLLDoaO4iYKm7N7v7DqLzj8+Lp00zGwbMB359el0beJ7fXM24ghymjspLdigiAlw9czR7DjeyeRDeMBhP8hgHxD5Gsioo67KOu7cB9cCIHvaNp81PAs+7+9GYsg+b2Voz+72ZzewqWDO73cwqzKyipqYmju6lh6bWdl7ZeogFM4p1lZVIioj+f4Q/bjiY7FD6XSoPmN8C/Dxm/U1gorufD/xvuvlG4u4Pu/tcd59bVFTUD2H2j9e319LY2s786cXJDkVEAsVDs7lwwnD+uHHwjXvEkzz2AiUx6+ODsi7rmFkEyAdqe9i3xzbNbCTRU1u/O1nm7kfd/XiwvALICOoNCis3V5OTEebiySOSHYqIxLi6fBQb9h1l75HGZIfSr+JJHmuAMjMrNbNMogPgyzvVWQ7cGizfCKz06AjScmBxcDVWKVAGrI6jzRuBZ9y96WSBmY0OxlEws3lB7LWJdTc9uTsrN1fz0Skjyc4IJzscEYlxdXD143OD7KqrXpNHMIZxJ/AssAlY5u4bzOxeM7shqPYIMMLMKoFvAHcF+24AlgEbgT8Ad7h7e3dtxhx2MaeesoJoQnnHzNYC3wcW+yC5xGFr9XGq6hpZMEOnrERSTenIIZQV5/HHjYNr3CMST6XgNNGKTmX3xCw3ATd1s+8SYEk8bcZsu7yLsh8AP4gn3oHm+U3RS3SvmKbkIZKKFswYxY9f3s6xplaGZmckO5x+kcoD5hJYufkg544bxuj87GSHIiJdWDCjmLYO5+Wth5IdSr9R8khxdQ0tvLGrjvnTdWOgSKq6oKSA/JyM984SDAZKHinuxXdr6HBYoEt0RVJWJBzi8mlF/HlL9aB5UKKSR4p7fnM1I/OymDUuP9mhiEgP5k8vprahhbVVR5IdSr9Q8khhre0dvLilmvnTiwiFdFe5SCq7bGoR4ZCxcvPgOHWl5JHC3thVx9GmNo13iKSBgtxM5kwYPmjGPZQ8UtjKzdVkhkNcUjZobqQXSWvzZxSzcf9R9tcP/LvNlTxS2PObDnLR5ELysuK6HUdEkuzkhS2D4dSVkkeK2nmogW01DbrKSiSNTCnOo6Qw5725dwYyJY8UdfIvF413iKQPM2P+tGJeqTxEU2t7ssM5q5Q8UtTKzdWUFecxYURuskMRkQTMnzGKptYOXts2sJ/bquSRgo41tbJqRy3z9SBEkbRzUWkhuZlhnt88sB+UqOSRgl7ZeojWdmeBTlmJpJ3sjDCXTBnJyk3VA3pucyWPFPT85mryczK4cEJBskMRkdMwf3ox++qb2HJw4M5truSRYjo6nBc2V3P5tCIiYb09IunoiuAqyYF8w6A+nVLM2qoj1Da0aK5ykTQ2alg2s8blD+j7PeJKHma20My2mFmlmd3VxfYsM3sq2L7KzCbFbLs7KN9iZtf01qaZPWZmO8zs7eA1Oyg3M/t+UH+dmV14Jh1PVS9sriZk0efkiEj6mj+9mDd313G4oSXZoZwVvSYPMwsDDwDXAuXALWZW3qnabUCdu08B7gfuC/YtJzql7ExgIfCgmYXjaPMf3X128Ho7KLuW6BzoZcDtwEOn0+FU9/zmauZOLKQgNzPZoYjIGZg/vRh3ePHdgfntI55vHvOASnff7u4twFJgUac6i4DHg+WngQVmZkH5UndvdvcdQGXQXjxtdrYI+KlHvQ4UmNmYOOJPGwfqm9iw76gu0RUZAGaNy2dkXtaAHfeIJ3mMA/bErFcFZV3Wcfc2oB4Y0cO+vbW5JDg1db+ZZSUQB2Z2u5lVmFlFTU1NHN1LHSfPj+qRJCLpLxQy5k8v4sV3a2ht70h2OH0uFQfM7wamAx8CCoH/lsjO7v6wu89197lFRek1brBy80FKCnOYUpyX7FBEpA/Mnz6KY01tVOysS3YofS6e5LEXKIlZHx+UdVnHzCJAPlDbw77dtunu+4NTU83AT4ie4oo3jrTV1NrOK5WHWDB9FNEzfiKS7i4pG0lG2Fg5AO82jyd5rAHKzKzUzDKJDoAv71RnOXBrsHwjsNKjt1YuBxYHV2OVEh3sXt1TmyfHMYIxk08C78Qc44vBVVcXA/Xuvv+0ep2CXttWS1Nrhy7RFRlA8rIiXDx5xIC8ZLfX5BGMYdwJPAtsApa5+wYzu9fMbgiqPQKMMLNK4BvAXcG+G4BlwEbgD8Ad7t7eXZtBW0+Y2XpgPTAS+J9B+QpgO9FB9x8BXz+jnqeY5zYdZEhmmIsmFyY7FBHpQ/OnF7OtpoGdhxqSHUqfimuWIXdfQfTDO2WRjF0AABB/SURBVLbsnpjlJuCmbvZdAiyJp82gfH437ThwRzzxppuODue5jQe5bFoRWZFwssMRkT40f3ox/+O3G1m5uZovX1Ka7HD6TCoOmA86a6uOUHOsmavLRyc7FBHpYxNHDOGcoiED7tSVkkcKeG7jQcIh44ppGu8QGYgWzBjFqh21HG9uS3YofUbJIwU8t/EgF5UWkp+bkexQROQsmD+9mNZ255Wt6XXvWU+UPJJs56EGtlYf56pyzd0hMlDNmTicYdmRAXW3uZJHkj23MXr9t5KHyMCVEQ5x6dQiXthSTUfHwJggSskjyf648QAzxgxj/HDNVS4ykC2YUcyh4y2srTqS7FD6hJJHEh082kTFrjoWztRVViID3RXTiomEjD+8cyDZofQJJY8kWrF+P+7w8fMG1MOBRaQLBbmZXFI2kmfW7R8Qc5sreSTR79btZ/rooXoQosgg8fFZY9h7pJG396T/qSsljyTZd6SRil11XK9vHSKDxtUzR5MRNn63Lv0fy6fkkSQr1kd/eT5+3tgkRyIi/SU/J4NLy4pYsX5/2l91peSRJM+s28/MscMoHTkk2aGISD+6/vwx7Ktv4q096T3Hh5JHEuw5fIK39xzRQLnIIHTljFFkRkL8dm16n7pS8kiCX70VncPqEzplJTLoDM3OYP60Yn67dl9aT0+r5NHPOjqcp9+o4sOTR1BSqBsDRQajm+aOp7ahJa2ftBtX8jCzhWa2xcwqzeyuLrZnmdlTwfZVZjYpZtvdQfkWM7umtzbN7Img/B0ze9TMMoLyy82s3szeDl73kIZW7zzM7sMn+OyHxic7FBFJksumFlE0NIv/qKhKdiinrdfkYWZh4AHgWqAcuMXMyjtVuw2oc/cpwP3AfcG+5USnmJ0JLAQeNLNwL20+AUwHZgE5wFdijvOyu88OXveeToeTbVnFHoZmRVg4U+MdIoNVJBzi0xeO44Ut1VQfa0p2OKclnm8e84BKd9/u7i3AUmBRpzqLgMeD5aeBBcEc5IuApe7e7O47iE4hO6+nNt19hQeIznc+YP5EP97cxu/XH+D688eSk6kZA0UGs5vmlNDe4fw6GANNN/Ekj3HAnpj1qqCsyzrB/OT1wIge9u21zeB01ReIzn1+0ofNbK2Z/d7MZnYVrJndbmYVZlZRU5Naz87/3bp9NLa2c9PcAZMPReQ0TSnO48IJBfxHRVVaPq4klQfMHwRecveXg/U3gYnufj7wv4Ffd7WTuz/s7nPdfW5RUVE/hdo7d+ffX99NWXEeF5QUJDscEUkBN3+ohK3Vx1m143CyQ0lYPMljL1ASsz4+KOuyjplFgHygtod9e2zTzP4FKAK+cbLM3Y+6+/FgeQWQYWYj44g/JazecZj1e+v564+WEj2jJyKD3aLZ4xiem8Ejr+xIdigJiyd5rAHKzKzUzDKJDoAv71RnOXBrsHwjsDIYs1gOLA6uxioFyoiOY3Tbppl9BbgGuMXd37sI2sxGB+MomNm8IPba0+l0Mjzyyg6G52bw6Qs7n/ETkcEqOyPMX108kT9tOsjOQw3JDichvSaPYAzjTuBZYBOwzN03mNm9ZnZDUO0RYISZVRL9tnBXsO8GYBmwkejYxR3u3t5dm0FbPwRGAa91uiT3RuAdM1sLfB9Y7GlyonDnoQae23SQv7p4ItkZGigXkfd94cMTyQiF+Mlf0uvbRySeSsFpohWdyu6JWW4Cbupm3yXAknjaDMq7jMndfwD8IJ54U81jr+4kEjK+cPHEZIciIimmeGg2nzh/LMsqqvjGVdPIz81IdkhxSeUB8wGh9ngzyyr2cMP54ygelp3scEQkBd12SSmNre387PWdyQ4lbkoeZ9kDL2yjqbWdr10+OdmhiEiKKh87jCtnFPN/XtrOkRMtyQ4nLkoeZ1FV3Qn+/fVd3DSnhCnFQ5MdjoiksP96zTSON7fx4J+3JTuUuCh5nEX3P7cVM/j7q8qSHYqIpLjpo4fxqQvG8dirO9lf35jscHql5HGWbDlwjF++VcWXPjKJMfk5yQ5HRNLAP1w5FRzuf+7dZIfSKyWPs6C9w7n7l+sYlp3B1y4/J9nhiEiaKCnM5YsfnsiyiipWbU/t29iUPM6Cn/xlB2/uPsL/uGEmBbmZyQ5HRNLIP1w1lZLCHL75i3U0trQnO5xuKXn0se01x/nOs1u4csYoFs3WTIEikpghWRHu+8x57Ko9wXee3ZLscLql5NGHmlrb+Ydla8mKhPh/P3WunmElIqflI+eM5AsXT+Qnr+7g5a2p9XTwk5Q8+oi7882n17F2zxG+feN5uiFQRM7IXddOZ2rxUL7+xJtUVh9LdjgfoOTRR777p60sX7uPby6cxsJzNUugiJyZIVkRHvnSXLIiYf76sTXUHm9OdkinUPI4Q+7OQ3/exvee38pNc8bztct0dZWI9I3xw3P58a1zqT7azF89spqDR1NnyloljzPQ3uHc85sN3PeHzXzi/LEs+dQsjXOISJ+aXVLAj744l121DXz6wVdT5hSWksdp2lXbwBceWcXPXt/F31w6me/dPJvMiP45RaTvXTq1iGV/82Ga2zr41IOvsmzNnqRPXatPuwRFnz1TyTXffYn1VfXc95lZ3H3dDEIhfeMQkbPn3HH5/OrrH2HGmGF88xfr+PyPV7FhX33S4olrPo/Brr3DWb+3nmfW7uOpNXs41tzGVeWj+H8WncvofF1VJSL9o6Qwl6VfvZila/bw/63YxMe//woXTy7kcxdN5NKykf16U3JcycPMFgLfA8LAj939W522ZwE/BeYQnRr2ZnffGWy7G7gNaAf+zt2f7anNYLrapcAI4A3gC+7e0tMx+trBo00sf3sfe+pOsPvwCd7afYT6xlbCIeO6WWO47ZJSZpcUnI1Di4j0KBQyPnfRBD4+awxPVezm8Vd38Xc/fwszOHdsPlOK8ygZnsMFE4dzxbTisxZHr8nDzMLAA8BVQBWwxsyWu/vGmGq3AXXuPsXMFgP3ATebWTnR+clnAmOBP5nZ1GCf7tq8D7jf3Zea2Q+Dth/q7hhn+g/QlZpjzSxZsYmh2RFKhudyVfkoPlY2kkumjGREXtbZOKSISELyczO4/dJz+PJHS1lbVc/LW2tYtf0wq3cc5jdvN7Jo9rjkJg9gHlDp7tsBzGwpsIjovOQnLQL+NVh+GviBRS87WgQsdfdmYEcwx/m8oN4H2jSzTcB84HNBnceDdh/q7hhnYx7zaaOHsvaeq9NmOkgRGbwi4RBzJg5nzsTh75W1tHXQ2Hp2n4sVT/IYB+yJWa8CLuqujru3mVk90dNO44DXO+07Lljuqs0RwBF3b+uifnfHOBQbiJndDtwerB43s+4eDjOy874DRL/26/P9c5hT+tRPx3zPWTxet+9VGvcx7t+//u7jmfj8wPy86KlPE3vbecANmLv7w8DDvdUzswp3n9sPIfWrgdivgdgnGJj9Goh9goHZrzPtUzyX6u4FSmLWxwdlXdYxswiQT3RQu7t9uyuvBQqCNjofq7tjiIhIP4sneawBysys1MwyiQ6AL+9UZzlwa7B8I7AyGItYDiw2s6zgKqoyYHV3bQb7vBC0QdDmb3o5hoiI9LNeT1sF4wt3As8Svaz2UXffYGb3AhXuvhx4BPhZMCB+mGgyIKi3jOjgehtwh7u3A3TVZnDI/wYsNbP/CbwVtE13xzgDvZ7aSlMDsV8DsU8wMPs1EPsEA7NfZ9Qn0x/vIiKSKD2eREREEqbkISIiCRs0ycPM/pOZbTazDWb27Zjyu82s0sy2mNk1MeULg7JKM7srOVH3zsz+i5m5mY0M1s3Mvh/Evc7MLoype6uZbQ1et3bfavKY2XeC92mdmf3KzApitqX1e3VSusUby8xKzOwFM9sY/F/6z0F5oZk9F/xuPWdmw4Pybn8fU42Zhc3sLTN7JlgvNbNVQexPBRf3EFwA9FRQvsrMJiUz7p6YWYGZPR38n9pkZh/us/fK3Qf8C7gC+BOQFawXBz/LgbVAFlAKbCM6gB8OlicDmUGd8mT3o4t+lRC96GAXMDIouw74PWDAxcCqoLwQ2B78HB4sD092H7ro09VAJFi+D7hvILxXMf1Lq3i7iH8McGGwPBR4N3hvvg3cFZTfFfO+dfn7mIov4BvAk8AzwfoyYHGw/EPga8Hy14EfBsuLgaeSHXsPfXoc+EqwnAkU9NV7NVi+eXwN+JZHH5OCu1cH5e89PsXddwAnH5/y3iNZ3L2F6IMaFyUh7t7cD3wTiL3qYRHwU496neh9M2OAa4Dn3P2wu9cBzwEL+z3iXrj7H/39Jwy8TvReH0j/9+qkdIv3FO6+393fDJaPAZuIPv1hEdEPKoKfnwyWu/t9TClmNh74OPDjYN2IPirp6aBK5z6d7OvTwIKgfkoxs3zgUoIrVt29xd2P0Efv1WBJHlOBjwVfMV80sw8F5V09emVcD+Upw8wWAXvdfW2nTWnbpy58mehfQjBw+pVu8XYrOF1zAbAKGOXu+4NNB4BRwXK69Pe7RP8Q6wjW435UEnDyUUmpphSoAX4SnI77sZkNoY/eqwHzeBIz+xMwuotN/0y0n4VEv4p9CFhmZpP7MbzT0kuf/onoKZ6001O/3P03QZ1/Jnpv0BP9GZvEx8zygF8Af+/uR2P/8HZ3N7O0uQfAzK4Hqt39DTO7PNnx9KEIcCHwn9x9lZl9j+hpqvecyXs1YJKHu1/Z3TYz+xrwS4+e2FttZh1EHwrW06NXensky1nXXZ/MbBbRvyrWBv9pxwNvmtk8en4kzOWdyv/c50HHoaf3CsDMvgRcDywI3jNI8fcqAfE87ielmVkG0cTxhLv/Mig+aGZj3H1/cKrj5KnhdOjvR4EbzOw6IBsYRnSuoQIziwTfLrp6VFKVpfajkqqAKndfFaw/TTR59M17lewBnX4aNPpb4N5geSrRr2ZGdJ6R2EHY7UQHNCPBcinvD2rOTHY/eujfTt4fMP84pw56rQ7KC4EdRAfLhwfLhcmOvYu+LCT6RIKiTuUD5b1Kq3i7iN+ITsr23U7l3+HUQdhv9/T7mKovon9gnRww/w9OHTD/erB8B6cOmC9Ldtw99OdlYFqw/K/B+9Qn71XSO9dP/4CZwL8D7wBvAvNjtv0z0atftgDXxpRfR/RKkm1ET6ckvR899C82eRjRiba2AeuBuTH1vkx0oLkS+Otkx91NXyqJJve3g9cPB9J7lY7xdor9EqIXaKyLeY+uI3rO/3lgK9ErGwt7+31MxVen5DGZ6LP4KoNEcvJqzexgvTLYPjnZcffQn9lARfB+/ZroH4598l7p8SQiIpKwwXK1lYiI9CElDxERSZiSh4iIJEzJQ0REEqbkISIiCVPyEOlHwVNpd5hZYbA+PFiflNzIRBKj5CHSj9x9D/AQ8K2g6FvAw+6+M2lBiZwG3ech0s+Cx3u8ATwKfBWY7e6tyY1KJDED5tlWIunC3VvN7B+BPwBXK3FIOtJpK5HkuBbYD5yb7EBEToeSh0g/M7PZwFVEHz73D6k4OZJIb5Q8RPpRMOPcQ0TnwdhN9Amn/39yoxJJnJKHSP/6KrDb3Z8L1h8EZpjZZUmMSSRhutpKREQSpm8eIiKSMCUPERFJmJKHiIgkTMlDREQSpuQhIiIJU/IQEZGEKXmIiEjC/i9a+ZJeDCm13gAAAABJRU5ErkJggg==\n"
            ],
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": [
              "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\n"
            ],
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": [
              "iVBORw0KGgoAAAANSUhEUgAAAYAAAAEGCAYAAABsLkJ6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nO3deXxX9Z3v8dcne4AkkIUQQiCJBCSAoEYWxaWuqDNib3WqXaTW1juttp3bzp3RO3c6c53b+2hvO91utY5Tt3baqmOrUndxQQVZgiAIGBLCTvZA9v33vX/8ftAYE/ILWU6S834+Hjz45fzOOb/P7+SX8z7ne77n+zPnHCIi4j8RXhcgIiLeUACIiPiUAkBExKcUACIiPqUAEBHxqSivCxiI1NRUl52d7XUZIiJjxtatW6udc2m9PTemAiA7O5vCwkKvyxARGTPM7GBfz6kJSETEpxQAIiI+pQAQEfEpBYCIiE8pAEREfEoBICLiUwoAERGfUgCIiPiUAkBExKfG1J3AfvS7TYe8LqFXn1s6c0jXN5TvcyhrG+rtP1prG82/z6E01O9zrNMZgIiITykARER8SgEgIuJTCgAREZ9SAIiI+FRYAWBmK82syMxKzOyeXp6PNbMnQ89vMrPs0PQUM3vTzBrN7Bc9ljnfzHaGlvm5mdlQvCEREQlPvwFgZpHA/cC1QD5wq5nl95jtDuC4c2428BPgB6HprcA/An/by6p/CXwVyAv9W3kmb0BERM5MOGcAS4AS51ypc64deAJY1WOeVcDjocdPA1eYmTnnmpxz7xIMglPMLANIdM5tdM454NfAjYN5IyIiMjDhBEAmcLjbz0dC03qdxznXCdQBKf2s80g/6wTAzO40s0IzK6yqqgqjXBERCceovwjsnHvIOVfgnCtIS+v1e41FROQMhBMAR4Gsbj/PCE3rdR4ziwKSgJp+1jmjn3WKiMgwCicAtgB5ZpZjZjHALcCaHvOsAVaHHt8EvBFq2++Vc64MqDezZaHeP7cBzw24ehEROWP9DgbnnOs0s7uBV4BI4BHn3C4zuw8odM6tAR4GfmNmJUAtwZAAwMwOAIlAjJndCFztnNsNfB14DIgHXgr9ExGRERLWaKDOuReBF3tM+263x63AzX0sm93H9EJgQbiFiojI0Br1F4FFRGR4KABERHxKASAi4lMKABERn1IAiIj4lAJARMSnFAAiIj6lABAR8SkFgIiITykARER8SgEgIuJTCgAREZ9SAIiI+JQCQETEpxQAIiI+pQAQEfEpBYCIiE8pAEREfEoBICLiUwoAERGfUgCIiPiUAkBExKcUACIiPqUAEBHxKQWAiIhPKQBERHxKASAi4lMKABERn1IAiIj4lAJARMSnFAAiIj4VVgCY2UozKzKzEjO7p5fnY83sydDzm8wsu9tz94amF5nZNd2m/zcz22VmH5rZ780sbijekIiIhKffADCzSOB+4FogH7jVzPJ7zHYHcNw5Nxv4CfCD0LL5wC3AfGAl8ICZRZpZJvBNoMA5twCIDM0nIiIjJJwzgCVAiXOu1DnXDjwBrOoxzyrg8dDjp4ErzMxC059wzrU55/YDJaH1AUQB8WYWBUwAjg3urYiIyECEEwCZwOFuPx8JTet1HudcJ1AHpPS1rHPuKPAj4BBQBtQ5517t7cXN7E4zKzSzwqqqqjDKFRGRcHhyEdjMphA8O8gBpgMTzewLvc3rnHvIOVfgnCtIS0sbyTJFRMa1cALgKJDV7ecZoWm9zhNq0kkCak6z7JXAfudclXOuA/gjcOGZvAERETkz4QTAFiDPzHLMLIbgxdo1PeZZA6wOPb4JeMM550LTbwn1EsoB8oDNBJt+lpnZhNC1giuAPYN/OyIiEq6o/mZwznWa2d3AKwR76zzinNtlZvcBhc65NcDDwG/MrASoJdSjJzTfU8BuoBO4yznXBWwys6eB90PTtwEPDf3bExGRvvQbAADOuReBF3tM+263x63AzX0s+z3ge71M/yfgnwZSrIiIDB3dCSwi4lMKABERn1IAiIj4lAJARMSnFAAiIj6lABAR8SkFgIiITykARER8SgEgIuJTCgAREZ9SAIiI+JQCQETEpxQAIiI+pQAQEfEpBYCIiE8pAEREfEoBICLiUwoAERGfUgCIiPiUAkBExKcUACIiPqUAEBHxKQWAiIhPKQBERHxKASAi4lMKABERn1IAiIj4lAJARMSnFAAiIj6lABAR8amwAsDMVppZkZmVmNk9vTwfa2ZPhp7fZGbZ3Z67NzS9yMyu6TZ9spk9bWYfmdkeM1s+FG9IRETC028AmFkkcD9wLZAP3Gpm+T1muwM47pybDfwE+EFo2XzgFmA+sBJ4ILQ+gJ8BLzvnzgYWAXsG/3ZERCRc4ZwBLAFKnHOlzrl24AlgVY95VgGPhx4/DVxhZhaa/oRzrs05tx8oAZaYWRJwCfAwgHOu3Tl3YvBvR4ZDR1eAI8eb2VvRQENrh9flANAVcHR0BbwuY9Tp6ArQFXBelwFAfUsHReUNHDvRQqd+V6NSVBjzZAKHu/18BFja1zzOuU4zqwNSQtM39lg2E2gBqoBHzWwRsBX4lnOuqeeLm9mdwJ0AM2fODKNcGSr7q5t4bXc5B2ua6b5LmRwfzYmWdr58UQ5x0ZF9Lj+UAs5RVN7A+pJqyutbaW7vItKMWakTmJueQMGsZOJjRqYWgMqGVt4/eIIPjpygub0TgEmxUSzOmsx5M6eQMil2xGppbOtk68HjFJU3cKi2CedgQmwUGUlxrJidSt7USQSPx4Zfc3sn/7aulEfX76e+tfPU9AiDnNSJXJ0/jazkCSNSi/QvnAAYrtc9D/iGc26Tmf0MuAf4x54zOuceAh4CKCgoGB2HNuNcQ2sHz24/xp6yehLjorh0bhrTk+KZEBvJseMtFFc28n9fLuJ3mw7xz385nyvz04e1noM1TTyz7SiVDW1MnhDNgulJJMRF0d4VoLiikZc+LOed4mquPyeDczKThrWWto4uXthZRuHB40QYzElPIC0huLOvqG/lraIq3iyqYlluCivnTyMmavj6WTjneP/QcV7cWU5LRxfTk+K4OC+NyAijoTV49P3YhgNMT4rj0+fOIHNK/LDVAvDizjLu+9NuyutbOXtaAhenTWL65Hga2zo5dqKFrQeP88t1+1iYmcQNi6YzMdar3Y+cFM5v4CiQ1e3nGaFpvc1zxMyigCSg5jTLHgGOOOc2haY/TTAAxGPVjW08un4/jW2dXJ2fzoVnpX5sJ5abOokVeWnMSpnAvzy/m6/8upBvXZHHt67IIyJiaI8ynXO8W1LNK7vKSYqP5q8KZrAwczKR3V7n2gVw9EQLz247ypNbDrPjSB2rzs1k0jDsXA7WNPFU4WFONHdwcV4qK2ankhAX/bF56lo6eHtvFe+V1lBS2chnC7KGZcdb19zBYxsOUFzZyKzkCaw6N5NpiXEfm6czEOCDwydYu6eSB9/ex3ULM1iWkzzkZwPOOX72ejE/XVvMgsxE/t/nzqW4ovFj8yzMTOKyOWm8U1LN23urOHK8mS8uy2ZaUlwfa5WREM7hyRYgz8xyzCyG4EXdNT3mWQOsDj2+CXjDOedC028J9RLKAfKAzc65cuCwmc0NLXMFsHuQ70UG6XBtMw+u20dbZ4CvrMjlsrlT+zyCvWh2Ks/dfRE3nT+Dn71ezN2/f5+W9q4hq6WjK8DvNh/ipQ/LmZeRyDcuz2Nx1pSP7fxPypwcz9cuO4trF0yjqLyem365gWMnWoasFoAdR07wq3f3Y2bceUku1y7I+MTOHyApPpq/XDSdL1+UQ0dXgIfe2cdHZfVDWsuB6iY+/cv1lFY1ccOi6Xz1ktxP7PwBoiIiOH9WMt/41Gxmp03iTx8c4+mtR+gMDF17fEdXgL//ww5+uraYz5w3g2e+fhEXZCf3Om9sdCRXzkvnqxfn0hlwPLhuH3uGeNvIwPQbAM65TuBu4BWCPXWecs7tMrP7zOyG0GwPAylmVgJ8m9DRvHNuF/AUwZ37y8BdzrmTe4lvAL81sx3AYuD/DN3bkoH6qKyeX71bSlx0JF+79Kyw2mljoyL54U3n8A/XzeOlD8v54sObqGse/EXilvYuHl2/n93H6rluwTQ+t2Rmv9caIsy4OC+N25Znc/R4C6vuX8+uY3WDrgVgfUk1T2w5zIwp8Xz9srOYlTKx32VmT53E1y87i6kJcfxm40G2HKgdklreP3ScTz+wntqmdr68IodluSlE9HNEPyE2ii8un8WV86ay7fAJfvPeQdo6Bx/WjW2d3PF4IU8VHuGbl8/mRzefQ3Rk/8eUWckTuOuy2UxNjOW3mw7y/sHjg65FzowFD9THhoKCAldYWOh1GSPqd5sOUV7fyt7yBkqrG2nrDDAreSK5aROZPXVSv3/84di8v5bnth9l+uR4bls+q9cj254+t/TjF+Rf2FHGf3tyO9mpE/j1l5cO+NT+d5sOAcEmlMc3HKCqoY2bC2ZwzozJA1oPQEH2FFY/spnG1k5+tbqApbkpA14HQCDgWP3IZt4pqWb+9ET+qiArrB1cd22dXfxu0yGKKxu54uyp/Gp1wRk3wazbW8Vf/2YrUxNjefz2JWzYVzPgdRQeqOXZU7/r7FNNZT1/n/2prG/l9se28FF5A//7xgXcuuTjy5/8fZ5OW2cXv914iJKqRq5bMI0VeWkDqqE3XQFHcUUD+6ubOFjbzISYSHJSJzJ3WgJTE+IG/D7HAzPb6pwr6O053Qk8ym0sreH/vV7My7vKOd7cQSDgWF9SzWMbDvCLN0rYW9HAmYa4c47Xdlfw7Paj5KVP4isX54S18+/N9edk8NjtF3DsRCuf+eUGSiob+1+oh8qGVv5t3T6ON7ez+sLsM9r5Q/DC7NNfu5C0xFhue2QzL39YPuB1tHcG+PZT23mnpJplucncumTmgHf+EDxLum15NufNnMzrH1XyP57ZeUZdIp/ddpSvPL6F7NSJ/OdfLyc7tf+zkN4UZCfz+aWzKK8LbuvapvYBr6OksoFPP7CB0qomfnVbwSd2/uEKbptZLJieyIsflvPqrvJBfZZ3H6vnZ68X8+uNB9lQWoMRvKb10ofl/Pz1YrYd0plGTzoDGKWcc/zo1SLuf3MfZ09L4NPnZp7aObd3BthTXs9ruyuobWpnTvokVi3OZMqEmLDX3xVwPLvtKFsPHef8WVO4cXFmr+3rfenrSOrDo3V86dHNdAUcj96+hMVZ4e3Ev/fCHn676SBmxpcuzCZz8plfOD1ZW21TO7c/toUPDp/gv18zl69fdlZYR9+V9a3c/bttbD5Qy9X56Vw6J23QF05Phu1be6tYMTuVn996LskT+/99BQKOf30t+DlYmpPMv68uIDH0OQjnKLsvB2ua+PV7B4mKML64fBZ/t/LssJbbvL+Wr/66kOhI45EvXdBnSA+ktoBzPLf9KFsOHGdJdjI3LJ4+oDPbmsY2ntl2lNLqJtImxXJVfjpzpyWcCuy6lg7+c+thSquaBvQ5GC9OdwagABilHly3j++/9BEXZE/hhkW975w7AwE2ltaydncFAFfPT2dpTkq/O/LapnaeKjzModpmPjV3KlfOmzrgP4jTnUofqG7itkc2U1Hfyn+/Zi63X5TTZ01dAccv3ijhp2v3kjwxhi9dmD3oPvTda2vt6OLv/7CD57Yf4/qFGfzzDfNPddvszcbSGr7x+200tnby/c8spKlt6C5sA0RGwD8+t4vUiTHc//nzOHfmlD7nLa9r5X8+u5O1eyq5dUkW/+uGBR+7KD+YAIBgt9XHNxygvrWDe649m6+syO2zJ1dnV4AH1+3jZ68XkzVlAo/dvoSZKX1fJxpobc45Xt1dwbq9VeSmTeTm87NIij/92WhnIMCGkhrW7qkgKtK4On8aF2Qn9/m38oetR/jgSB3/cuMCvrhs1oDqG8sUAGPMoZpmrv7pOi6dk8Ylef0ffR5vbufZbUcprmwkdVIsK+dPY15GwieW6+gKsO3QCV76sAyAGxdnsijMI/Se+mtLrWpo494/7mDtnkoKZk3hW1fmsTw3hajQUVlnV4BXdlXw0Nv7+OBIHYuzJrNq0XRih+DGsp61Oed4cF0pP36tiLioSL55RR43nT+DKd2OwHcfq+ena/fy6u4KclMn8ssvnM/caQmD3sn2VtvOI3V87bdbOXqihesWZvA3V+SRl55wap7qxjae3HKY+98soTPg+B/Xns3qC7M/8fscitqa2zt5ZttRdh2r54LsKXz14lyumJd+aifa3hlgfUk1P1m7lx1H6rj+nAz+96oFH9t2vTnT2goP1PKnHceIiojg+oUZnDMj6dRn5qSAc3x4tI5XQ2fA+RmJ3LBoOon9BEbAOV7+sJwPDp/g9e9cytReek6NRwqAMcQ5x5ce3ULhgVrWfudS3vyoKuzlPipv4OUPy6lqbCMpPpq50xLISIqjozPA8eYOth8+QUtHF7OSJ/BXBVn9/hGfTjgX05xz/PH9o9z3/G7qWjpImRhD/vREmtu7OFTbTFVDGzOmxPOdq+fQ0j50XRP7qm1fVSP3/Wk36/YGt+mc9EkkxkWzv7qJmqZ2EuKi+MqKXO64OOfUxdHhCAAINkv8+9vBO2ab2rtInRRLTuoEapva2VcVvCH+mvnp/M/r8/vskTVUtTnniIwwfvZ6MWV1rUxLjGPGlHjiYyLZcaSOupYOUifF8L9uWMD152SEtc7B1Fbd0MaThYc5eqKFiTGRLM6aTNKEGKIjjaPHWyiqaKChtZNpiXGsXDBtQHc6X3hWClf/9G2uyk/n/s+dd8Y1jiWnCwDdijfKvLCzjHV7q/juX+STkRR+O7iZMS8jkTnpCew4coJdx+rZfugEm0MXHCMM8qcnsTQnmdzUiSPSBmpmfOb8GVx/TgZvFVXxws4yDtc2Myk2iqU5yaxanMnlZ08lMsKGfEfbm7PSJvHY7Rew7fAJ3ttXw6b9tbR1dHFVfjpz0hP4zPkz+m12GCpJ8dH87TVz+fKKHP6w9QjFlQ0cqG5mZvIEbjo/ixWzU1k4Y3jvaj7JzLhlyUxuOn8Gr+6u4Pkdx6hr6aChtZPLz57KX5yTwcV5acN6V3N3qQmxfO2ysyipbGTz/lreK63h5PBGsVER5KUnsGB6IgsykwbcCy47dSJ3f2o2P35tLzefX8llc6cOwzsYOxQAo0hXwPH9lz5i/vREblt+Zm2UkRHGuTOncO7MKXR2BWhu7yImKoLoyIgBXeQdSnHRkaxcMI2VC6Z58vrdmRnnzZzCeTOncNenvK4GkifG8NVLcr0uA4CoyAiuW5jBdQvDO8ofThFmzElPYE56wqmB/9o6A0yMjSQqYnBB9F8vzeXZ7Uf5Py/uGZIL/GOZuoGOImv3VHDkeAvfuHz2J9o9z0RUZASJ8dHERUd6tvMXGazICCMuOpKk+OhB7/wh2P3065fNZm9FI++dwb0U44kCYBR5bP0BMifHc+W84R1cTcTv/uKcDJInxvDohgNel+IpBcAoUVTewHulNXxh2awhOfoXkb7FRUdy65IsXt9TweHaZq/L8Yz2NKPE4+8dIDYqglsuyOp3XhEZvC8sm4WZ8R8bD3pdimcUAKNAXXMHz7x/lFWLpw+qa6aIhC8jKZ6V86fxxJbDQzqS7ViiABgFXt5VRktHF59f6p+7E0VGg88vm0ldSwdvfFTpdSmeUACMAi/sLCcrOZ5zRqjft4gELc1JIXVSLC/uLPO6FE8oADx2ormdDSXVXL9wuq/7I4t4ITLCWLkgnTc+qvRlM5ACwGOv7qqgM+C4fhTcfCPiR9ctzKClo4s3i/zXDKQA8NgLO8vISo5nQWai16WI+FKwGSiGF3zYDKQA8NCJ5nbWl1Rz3cIMNf+IeCQywrhm/jTe2OO/ZiAFgIde3a3mH5HR4PpQM9BbPmsGUgB46NVdFWROjmdhpnr/iHhpSU4yyRNjeDX05Up+oQDwSHtngA37qvnU2f4ejVBkNIiKjOCSvFTe3ltFIDB2viNlsBQAHik8WEtzexeXzvH3eOQio8Wlc9OoaWpn17F6r0sZMQoAj6zbW0V0pLH8rBSvSxER4OK8NADW7fXPdQAFgEfWFVVRMCv51FcPioi3UifFsjAz6dRXhvqBAsADFfWtfFTewKVz07wuRUS6uXROGu8fOkFdS4fXpYwIBYAHTh5hXDpHASAymlw6N42ugGNDSbXXpYwIBYAH1u2tIj0xlrOnJXhdioh0c27WZBLionzTDKQAGGFdAce7xdW+/zJqkdEoKjKCFbNTWbe3CufGf3dQBcAI21NWT11LBxfNTvW6FBHpxYq8VMrqWtlf3eR1KcNOATDCNpbWALAsV90/RUaj5aG/zfdCf6vjmQJghG0srSUndSLpiXFelyIivQj+fcby3j4FAABmttLMisysxMzu6eX5WDN7MvT8JjPL7vbcvaHpRWZ2TY/lIs1sm5k9P9g3MhZ0BRyb99ewNCfZ61JEpA9mxvLcFDaW1o776wD9BoCZRQL3A9cC+cCtZpbfY7Y7gOPOudnAT4AfhJbNB24B5gMrgQdC6zvpW8Cewb6JseKj8nrqWzvV/CMyyi0/K4XqxjZKKhu9LmVYhXMGsAQocc6VOufagSeAVT3mWQU8Hnr8NHCFBbu4rAKecM61Oef2AyWh9WFmM4DrgV8N/m2MDRtLawFYmqszAJHRbHlusJPGeL8OEE4AZAKHu/18JDSt13mcc51AHZDSz7I/Bf4OCJzuxc3sTjMrNLPCqqqx3Td3Y2kNs1ImkJEU73UpInIaWcnxZE6OH/fXATy5CGxmfwFUOue29jevc+4h51yBc64gLW3s3jkbCDg2769V+7/IGGBmLMtNYWNpzbgeHjqcADgKZHX7eUZoWq/zmFkUkATUnGbZi4AbzOwAwSaly83sP86g/jHjo/IG6lo61P4vMkYsPyuF480dFFU0eF3KsAknALYAeWaWY2YxBC/qrukxzxpgdejxTcAbLnj5fA1wS6iXUA6QB2x2zt3rnJvhnMsOre8N59wXhuD9jFqb9gdPJZcqAETGhJNDtY/nZqB+AyDUpn838ArBHjtPOed2mdl9ZnZDaLaHgRQzKwG+DdwTWnYX8BSwG3gZuMs5569vXQ7ZWFpzql1RREa/zMnxzJgSz+b9tV6XMmzCGozeOfci8GKPad/t9rgVuLmPZb8HfO80634LeCucOsaqk+3/V8xL97oUERmApTkpvFlUiXNuXI7dpTuBR8DeygaON6v9X2SsWZqbTG1TO8Xj9H4ABcAI2HSy/796AImMKctyggdtm8bp/QAKgBGwsbSGzMnxZCVP8LoUERmArOR4MpLi2DhOrwMoAIaZc45N+2t196/IGGRmLM1JZtM4HRdIATDMiisbqW1qV/u/yBi1NDc4LlDpOPx+AAXAMDvZdniyLVFExpaT1+7GY3dQBcAw21hay/SkOLKS1f9fZCzKSZ1I6qTYcXkhWAEwjILt/zUszU0Zl32IRfzAzFiam8ym/ePvOoACYBjtq2qkurFd3T9FxrhlOcmU1bVyuLbF61KGlAJgGJ0c/18XgEXGtpNjeG3cP76agRQAw2jT/lrSE2OZlaL+/yJjWd7USSRPjDl1U+d4oQAYJs45NpbWsDRH7f8iY52ZsSQ7+dSovuOFAmCY7K9uoqqhTTeAiYwTS3OTOXK8haMnxs91AAXAMNm0X+3/IuPJ0tC9PJvH0VmAAmCYbCqtIXVSLLmpE70uRUSGwNxpCSTGRY2r6wAKgGEQbP8Pjv+j9n+R8SEywliSk3zq7H48UAAMg0O1zZTXt7JM/f9FxpWlOSnsr26isr7V61KGhAJgGGxS/3+Rcelkp47xMjy0AmAYbNxfQ8rEGGZPneR1KSIyhPIzEpkUGzVuxgVSAAyDTaW1LMlR+7/IeBMVGUFB9pRxMzKoAmCIHa5t5uiJFo3/IzJOLc1JobiykZrGNq9LGTQFwBA71f//LLX/i4xHJ68DjIezAAXAENtUWsPkCdHMmZrgdSkiMgwWZiYRHx05LrqDKgCG2Mb9NSzJTiYiQu3/IuNRdGQE58+awsZxcCFYATCEjp1o4XBti7p/ioxzS3OSKapo4ERzu9elDIoCYAidHClQA8CJjG9Lc1NwbuxfB1AADKH39tWQGBfF2dMSvS5FRIbRoqwkYqMiTn3p01ilABgizjneLa7motmpRKr9X2Rci42KZElOMu+WVHldyqAoAIbIvqomjtW1cnFemteliMgIuCQvjb0VjZTXjd1xgRQAQ+Sd4uCRwMV5qR5XIiIj4eI5wb/1k3/7Y1FYAWBmK82syMxKzOyeXp6PNbMnQ89vMrPsbs/dG5peZGbXhKZlmdmbZrbbzHaZ2beG6g155Z3ianJSJ5KVrO//FfGDuekJpCXE8k5xtdelnLF+A8DMIoH7gWuBfOBWM8vvMdsdwHHn3GzgJ8APQsvmA7cA84GVwAOh9XUC33HO5QPLgLt6WeeY0dbZxXv7anT0L+IjZsbFeam8W1JNIOC8LueMhHMGsAQocc6VOufagSeAVT3mWQU8Hnr8NHCFBUdCWwU84Zxrc87tB0qAJc65Mufc+wDOuQZgD5A5+LfjjfcPnqClo4sVsxUAIn5ycV4qtU3t7C6r97qUMxJOAGQCh7v9fIRP7qxPzeOc6wTqgJRwlg01F50LbOrtxc3sTjMrNLPCqqrR2db2TnEVkRHGco3/I+IrF4UO+t4eo9cBPL0IbGaTgD8Af+Oc6zVCnXMPOecKnHMFaWmjs4fNO8XVnDdzMglx0V6XIiIjaGpCHPMyEnln79i8DhBOABwFsrr9PCM0rdd5zCwKSAJqTresmUUT3Pn/1jn3xzMpfjSoamjjw2N16v4p4lOXzEml8GAtDa0dXpcyYOEEwBYgz8xyzCyG4EXdNT3mWQOsDj2+CXjDOedC028J9RLKAfKAzaHrAw8De5xzPx6KN+KV1/dU4BxcOS/d61JExANXzkuno8uxbu/YawbqNwBCbfp3A68QvFj7lHNul5ndZ2Y3hGZ7GEgxsxLg28A9oWV3AU8Bu4GXgbucc13ARcAXgcvNbHvo33VD/N5GxNo9FWROjmdehoZ/FvGj82ZOIXliDGt3V3hdyqz5LB4AAArHSURBVIBFhTOTc+5F4MUe077b7XErcHMfy34P+F6Pae8CY368hOb2Tt4prubWJTP19Y8iPhUZYVx+9lRe3VVOR1eA6Mixc3/t2Kl0FHq3uJq2zgBX5av5R8TPrpyXTn1rJ1sOjK3B4RQAg/Da7goS4qJYou//FfG1S+akEhMVwWtjrBlIAXCGugKONz6q5FNzp46pUz4RGXoTYqJYMTuVtXsqCPZ/GRu05zpD2w4dp6apXc0/IgLAVfnpHK5toaiiwetSwqYAOEPP7ygjJjKCS+eq/7+IwBXzphJh8MKOMq9LCZsC4Ax0dgV4fscxLj97Kom6+1dECN4VfOFZqTy3/diYaQZSAJyB9ftqqG5s58Zzp3tdioiMIqsWT+dQbTPvHzrhdSlhUQCcgee2HSUxLorL5k71uhQRGUVWLphGbFQEz23vOVrO6KQAGKCW9i5e2VXOdQsziIuO9LocERlFEuKiuTI/ned3lNHRFfC6nH4pAAbotT0VNLV3sWrxmP36AhEZRjcuzqS2qZ13x8A3hSkABuiZ94+QkRTHUt38JSK9uHROGpMnRPPHbaO/GUgBMACHapp5a28VnzlvBhERGvtHRD4pJiqCGxdn8vKHZVQ2tHpdzmkpAAbgNxsPEGHG55fN9LoUERnFbls+i44ux+83He5/Zg8pAMLU3N7Jk1sOs3L+NDKS4r0uR0RGsdy0SVwyJ43fbjpIe+fovRisAAjTs9uOUd/ayZcuyva6FBEZA26/MJvKhjZe3lXudSl9UgCEwTnH4xsOkJ+RSMGsKV6XIyJjwKVz0shOmcDjGw54XUqfFABheGtvFUUVDXzpwmx98YuIhCUiwrhteTZbDx4ftd8ToADoRyDg+OHLRWQlx3Pjuer7LyLhu3XJTNISYvnhy0WjcnwgBUA/XthZxu6yer591RxiorS5RCR88TGRfPPy2Ww+UMtbo/BL47VHO42OrgA/fm0vc9MTuGGRjv5FZOA+e8FMspLj+eHLRQQCo+ssQAFwGk8VHmZ/dRN/e81cInXjl4icgZioCL591Rx2l9Xzpx3HvC7nYxQAfSira+H7L33EkpxkrpynUT9F5MzdsCiThZlJ3Pen3dQ0tnldzikKgF445/j7P+yks8vxw5vOUc8fERmUyAjjRzcvor61g+8+t8vrck5RAPTiiS2HeXtvFfdedzazUiZ6XY6IjANzpyXwN1fO4YWdZfzpg9HRFKQA6GHnkTr+5fndXHhWCl9YOsvrckRkHPmvl+SyKGsy//DMTopHwZfHKwC6OVTTzO2PbWbKhBh++tnFGvFTRIZUVGQEv7j1XGKjI1n9yGbK67wdLVQBEFLZ0MrqRzfTGXA8/uUlTE2M87okERmHspIn8NjtFwTHFnt0Myea2z2rRQFAsNln1S/WU1bXwsOrC5g9dZLXJYnIODZ/ehIPfuF8SquaWHX/evZ61Bzk6wAIBBxPbTnMTQ9uwICn//pCzp+lb/oSkeG3Ii+V39+5jKa2Lj59/3qe2350xIeL8GUAOOfYWFrDjQ+s5+/+sINFWZNZ840VLMhM8ro0EfGR82dN4U/fuIjZ6Ql864nt3Pzge7x/6PiIvX7UiL2Sx443tVNc2ciGfdWs+eAYpVVNZCTF8eO/WsSNizN1wVdEPJGRFM8fv3YhTxUe5l9f3ct/eWBDcPiZxdNZmpNM3tQEkiZED8trhxUAZrYS+BkQCfzKOff9Hs/HAr8GzgdqgM865w6EnrsXuAPoAr7pnHslnHUOlc6uABf94A0q6ttCtcLSnGS+siKXT5+bSXxM5HC8rIhI2CIjjFuXzOQvF03nj+8fYc32Y/zwlaJTz89KmcBbf3vZkN+U2m8AmFkkcD9wFXAE2GJma5xzu7vNdgdw3Dk328xuAX4AfNbM8oFbgPnAdGCtmc0JLdPfOodEVGTwC5pTJsWQl57A/OmJTE1QDx8RGX0mxUZx2/JsblueTXldK7vL6thb0UhzW+ewjEgQzhnAEqDEOVcKYGZPAKuA7jvrVcA/hx4/DfzCgtWuAp5wzrUB+82sJLQ+wljnkLn3unnDsVoRkWEzLSmOaUlxXH52+rC9RjgBkAl0/2r7I8DSvuZxznWaWR2QEpq+sceyJ8dV7m+dAJjZncCdoR8bzayot/mGUCpQPcyvMVad2jaf97iQ0/GotrA+N6N1uw1zXaPmb2oUbv+R2DZ9Dmkw6i8CO+ceAh4aqdczs0LnXMFIvd5Yom3TN22bvmnb9M3rbRNON9CjQFa3n2eEpvU6j5lFAUkELwb3tWw46xQRkWEUTgBsAfLMLMfMYghe1F3TY541wOrQ45uAN1zwjoY1wC1mFmtmOUAesDnMdYqIyDDqtwko1KZ/N/AKwS6bjzjndpnZfUChc24N8DDwm9BF3lqCO3RC8z1F8OJuJ3CXc64LoLd1Dv3bOyMj1tw0Bmnb9E3bpm/aNn3zdNvYaPymehERGX6+HApCREQUACIivqUA6MbMVppZkZmVmNk9XtfjNTM7YGY7zWy7mRWGpiWb2WtmVhz6f4rXdY4EM3vEzCrN7MNu03rdFhb089DnaIeZnedd5cOrj+3yz2Z2NPS52W5m13V77t7Qdikys2u8qXpkmFmWmb1pZrvNbJeZfSs0fdR8bhQAId2GvLgWyAduDQ1l4Xefcs4t7tZX+R7gdedcHvB66Gc/eAxY2WNaX9viWoI93vII3sT4yxGq0QuP8cntAvCT0OdmsXPuRYAeQ8OsBB4I/d2NV53Ad5xz+cAy4K7QNhg1nxsFwJ+dGvLCOdcOnByeQj5uFfB46PHjwI0e1jJinHNvE+zh1l1f22IV8GsXtBGYbGYZI1PpyOpju/Tl1NAwzrn9QPehYcYd51yZc+790OMGYA/BkRBGzedGAfBnvQ15kdnHvH7hgFfNbGtoSA6AdOdcWehxOTB8A5WMfn1tC32W4O5QM8Yj3ZoJfbtdzCwbOBfYxCj63CgA5HRWOOfOI3hqepeZXdL9ydDNfupHjLZFD78EzgIWA2XAv3pbjrfMbBLwB+BvnHP13Z/z+nOjAPgzDU/Rg3PuaOj/SuAZgqfrFSdPS0P/V3pXoef62ha+/iw55yqcc13OuQDw7/y5mcd328XMognu/H/rnPtjaPKo+dwoAP5Mw1N0Y2YTzSzh5GPgauBDPj7sx2rgOW8qHBX62hZrgNtCvTqWAXXdTvnHvR7t1p8m+LmBvoeGGZdCQ+I/DOxxzv2421Oj53PjnNO/0D/gOmAvsA/4B6/r8Xhb5AIfhP7tOrk9CA7z/TpQDKwFkr2udYS2x+8JNmd0EGybvaOvbQEYwR5l+4CdQIHX9Y/wdvlN6H3vILhTy+g2/z+EtksRcK3X9Q/ztllBsHlnB7A99O+60fS50VAQIiI+pSYgERGfUgCIiPiUAkBExKcUACIiPqUAEBHxKQWAyBkyM2dm/9Ht5ygzqzKz572sSyRcCgCRM9cELDCz+NDPVzHO72yV8UUBIDI4LwLXhx7fSvDGKJExQQEgMjhPEBzeIA44h+BojyJjggJAZBCcczuAbIJH/y96W43IwER5XYDIOLAG+BFwGcFxXkTGBAWAyOA9Apxwzu00s8u8LkYkXAoAkUFyzh0Bfu51HSIDpdFARUR8SheBRUR8SgEgIuJTCgAREZ9SAIiI+JQCQETEpxQAIiI+pQAQEfGp/w+csI7QSM0UHgAAAABJRU5ErkJggg==\n"
            ],
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": [
              "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\n"
            ],
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ],
      "execution_count": null,
      "metadata": {
        "id": "AakEBcuglLZ_",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "6021b615-5cc1-4f57-ab47-79fdccb67132"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "idx = 10\n",
        "\n",
        "train_df[train_df.id==idx][['S1']].plot()\n",
        "train_df[train_df.id==idx][['S2']].plot()\n",
        "train_df[train_df.id==idx][['S3']].plot()\n",
        "train_df[train_df.id==idx][['S4']].plot()\n",
        "# plt.plot(train_df[train_df.id==idx]['Time'], train_df[train_df.id==idx]['S1'])"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 26,
          "data": {
            "text/plain": [
              "<matplotlib.axes._subplots.AxesSubplot at 0x7f8253438588>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": [
              "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\n"
            ],
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": [
              "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\n"
            ],
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": [
              "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\n"
            ],
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": [
              "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\n"
            ],
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ],
      "execution_count": null,
      "metadata": {
        "id": "TLIw3sFWXvH2",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "4c57ac6c-c6f9-4002-d216-b63c708aed38"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plt.figure(figsize=(16,12))\n",
        "sns.heatmap(pd.concat([train_df2[cols], targets.drop(['id'], axis=1)], axis=1).corr())"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 21,
          "data": {
            "text/plain": [
              "<matplotlib.axes._subplots.AxesSubplot at 0x7f1739924eb8>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": [
              "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\n"
            ],
            "text/plain": [
              "<Figure size 1152x864 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ],
      "execution_count": null,
      "metadata": {
        "id": "_RDmnMDS5SKa",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 803
        },
        "outputId": "45ca2814-ce44-46c3-cb1b-7fb53ddb7815"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# CNN"
      ],
      "metadata": {
        "id": "OjJdd9Cbj3fP",
        "colab_type": "text"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# del model0, model1, model2, hist0, hist0_df, hist1, hist1_df, hist2, hist2_df\n",
        "# gc.collect()"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 86,
          "data": {
            "text/plain": [
              "29352"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ],
      "execution_count": 86,
      "metadata": {
        "id": "lqDqGbMOfz4t",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "db298bfe-e900-4a6a-9c12-f3263b1d85ef"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "SCALE = False   # True\n",
        "\n",
        "if SCALE:     \n",
        "    sc_inp = StandardScaler()\n",
        "    X = sc_inp.fit_transform(train_df.iloc[:, 1:].values)\n",
        "    X_test = sc_inp.transform(test_df.iloc[:, 1:].values)\n",
        "else: \n",
        "    X = train_df.iloc[:, 1:].values\n",
        "    X_test = test_df.iloc[:, 1:].values\n",
        "\n",
        "# reshape arrays\n",
        "X = X.reshape(2800, 375, 5, 1)\n",
        "X_test = X_test.reshape(700, 375, 5, 1)\n",
        "y = targets[['X', 'Y', 'M', 'V']]\n",
        "\n",
        "X.shape, y.shape, X_test.shape"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 87,
          "data": {
            "text/plain": [
              "((2800, 375, 5, 1), (2800, 4), (700, 375, 5, 1))"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ],
      "execution_count": 87,
      "metadata": {
        "id": "uWG6txovM8BS",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "a7eccae5-3b73-4498-c8c3-4d5798c5de9c"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "weight1 = np.array([1,1,0,0])\n",
        "weight2 = np.array([0,0,1,1])\n",
        "\n",
        "def my_loss(y_true, y_pred):\n",
        "    divResult = Lambda(lambda x: x[0]/x[1])([(y_pred-y_true),(y_true+0.000001)])\n",
        "    return K.mean(K.square(divResult))\n",
        "\n",
        "\n",
        "def my_loss_E1(y_true, y_pred):\n",
        "    return K.mean(K.square(y_true-y_pred)*weight1)/2e+04\n",
        "\n",
        "def my_loss_E2(y_true, y_pred):\n",
        "    divResult = Lambda(lambda x: x[0]/x[1])([(y_pred-y_true),(y_true+0.000001)])\n",
        "    return K.mean(K.square(divResult)*weight2)"
      ],
      "outputs": [],
      "execution_count": 88,
      "metadata": {
        "id": "R4OeSBm7Odda",
        "colab_type": "code",
        "colab": {}
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# x_train, x_valid, y_train, y_valid = train_test_split(X, y, test_size=0.3, shuffle=True, random_state=SEED)\n",
        "# x_train.shape, x_valid.shape"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "id": "fbuiCA9io2Gw",
        "colab_type": "code",
        "colab": {}
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow as tf\n",
        "from tensorflow.keras.layers import *\n",
        "from tensorflow.keras.callbacks import *\n",
        "from tensorflow.keras.optimizers import *\n",
        "import tensorflow.keras.backend as K\n",
        "\n",
        "\n",
        "def build_cnn_model():\n",
        "\n",
        "    activ = 'elu'        # 'relu'\n",
        "    padding = 'valid'    # 'same'\n",
        "    nf = 16\n",
        "    fs = (5,1)    # (3,1)\n",
        "\n",
        "    inp = Input(shape=X.shape[1:])\n",
        "\n",
        "    # layer-1\n",
        "    x = Conv2D(nf, fs, padding=padding, activation=activ)(inp)\n",
        "    x = BatchNormalization()(x)\n",
        "    x = MaxPooling2D(pool_size=(2, 1))(x)\n",
        "    \n",
        "    # layer-2\n",
        "    x =Conv2D(nf*2, fs, padding=padding, activation=activ)(x)\n",
        "    x = BatchNormalization()(x)\n",
        "    x = MaxPooling2D(pool_size=(2, 1))(x)\n",
        "\n",
        "    # layer-3\n",
        "    x = Conv2D(nf*4, fs, padding=padding, activation=activ)(x)\n",
        "    x = BatchNormalization()(x)\n",
        "    x = MaxPooling2D(pool_size=(2, 1))(x)\n",
        "\n",
        "    # layer-4\n",
        "    x = Conv2D(nf*8, fs, padding=padding, activation=activ)(x)\n",
        "    x = BatchNormalization()(x)\n",
        "    x = MaxPooling2D(pool_size=(2, 1))(x)\n",
        "\n",
        "    # layer-5\n",
        "    x = Conv2D(nf*16, fs, padding=padding, activation=activ)(x)\n",
        "    x = BatchNormalization()(x)\n",
        "    x = MaxPooling2D(pool_size=(2, 1))(x)\n",
        "\n",
        "    # layer-6\n",
        "    x = Conv2D(nf*32, fs, padding=padding, activation=activ)(x)\n",
        "    x = BatchNormalization()(x)\n",
        "    x = MaxPooling2D(pool_size=(2, 1))(x)\n",
        "\n",
        "    # FC\n",
        "    x = Flatten()(x)\n",
        "    x = Dense(128, kernel_initializer='uniform', activation=activ)(x)\n",
        "    # x = BatchNormalization()(x)\n",
        "    x = Dropout(0.2)(x)\n",
        "    x = Dense(64, kernel_initializer='uniform', activation=activ)(x)\n",
        "    # x = BatchNormalization()(x)\n",
        "    x = Dropout(0.2)(x)\n",
        "    x = Dense(16, kernel_initializer='uniform', activation=activ)(x)\n",
        "    # x = BatchNormalization()(x)\n",
        "    x = Dropout(0.2)(x)\n",
        "    \n",
        "    out = Dense(4, kernel_initializer='uniform', activation='linear')(x)\n",
        "\n",
        "    model = tf.keras.models.Model(inputs=[inp], outputs=[out])\n",
        "\n",
        "    return model"
      ],
      "outputs": [],
      "execution_count": 89,
      "metadata": {
        "id": "7TR_chVOWArW",
        "colab_type": "code",
        "colab": {}
      }
    },
    {
      "cell_type": "code",
      "source": [
        "build_cnn_model().summary()\n",
        "\n",
        "# build_wavenet().summary()\n",
        "\n",
        "# model"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"model\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "input_1 (InputLayer)         [(None, 375, 5, 1)]       0         \n",
            "_________________________________________________________________\n",
            "conv2d (Conv2D)              (None, 373, 5, 16)        64        \n",
            "_________________________________________________________________\n",
            "batch_normalization (BatchNo (None, 373, 5, 16)        64        \n",
            "_________________________________________________________________\n",
            "max_pooling2d (MaxPooling2D) (None, 186, 5, 16)        0         \n",
            "_________________________________________________________________\n",
            "conv2d_1 (Conv2D)            (None, 184, 5, 32)        1568      \n",
            "_________________________________________________________________\n",
            "batch_normalization_1 (Batch (None, 184, 5, 32)        128       \n",
            "_________________________________________________________________\n",
            "max_pooling2d_1 (MaxPooling2 (None, 92, 5, 32)         0         \n",
            "_________________________________________________________________\n",
            "conv2d_2 (Conv2D)            (None, 90, 5, 64)         6208      \n",
            "_________________________________________________________________\n",
            "batch_normalization_2 (Batch (None, 90, 5, 64)         256       \n",
            "_________________________________________________________________\n",
            "max_pooling2d_2 (MaxPooling2 (None, 45, 5, 64)         0         \n",
            "_________________________________________________________________\n",
            "conv2d_3 (Conv2D)            (None, 43, 5, 128)        24704     \n",
            "_________________________________________________________________\n",
            "batch_normalization_3 (Batch (None, 43, 5, 128)        512       \n",
            "_________________________________________________________________\n",
            "max_pooling2d_3 (MaxPooling2 (None, 21, 5, 128)        0         \n",
            "_________________________________________________________________\n",
            "conv2d_4 (Conv2D)            (None, 19, 5, 256)        98560     \n",
            "_________________________________________________________________\n",
            "batch_normalization_4 (Batch (None, 19, 5, 256)        1024      \n",
            "_________________________________________________________________\n",
            "max_pooling2d_4 (MaxPooling2 (None, 9, 5, 256)         0         \n",
            "_________________________________________________________________\n",
            "conv2d_5 (Conv2D)            (None, 7, 5, 512)         393728    \n",
            "_________________________________________________________________\n",
            "batch_normalization_5 (Batch (None, 7, 5, 512)         2048      \n",
            "_________________________________________________________________\n",
            "max_pooling2d_5 (MaxPooling2 (None, 3, 5, 512)         0         \n",
            "_________________________________________________________________\n",
            "flatten (Flatten)            (None, 7680)              0         \n",
            "_________________________________________________________________\n",
            "dense (Dense)                (None, 128)               983168    \n",
            "_________________________________________________________________\n",
            "dropout (Dropout)            (None, 128)               0         \n",
            "_________________________________________________________________\n",
            "dense_1 (Dense)              (None, 64)                8256      \n",
            "_________________________________________________________________\n",
            "dropout_1 (Dropout)          (None, 64)                0         \n",
            "_________________________________________________________________\n",
            "dense_2 (Dense)              (None, 16)                1040      \n",
            "_________________________________________________________________\n",
            "dropout_2 (Dropout)          (None, 16)                0         \n",
            "_________________________________________________________________\n",
            "dense_3 (Dense)              (None, 4)                 68        \n",
            "=================================================================\n",
            "Total params: 1,521,396\n",
            "Trainable params: 1,519,380\n",
            "Non-trainable params: 2,016\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "execution_count": 25,
      "metadata": {
        "id": "1wV8CdpCj1p9",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "d5d96bf0-bb2e-4467-caca-19fbc0061c46"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Model #0: Train for X,y"
      ],
      "metadata": {
        "id": "BAga_ncHT8zb",
        "colab_type": "text"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "train_target = 0\n",
        "\n",
        "# compile model\n",
        "BATCH_SIZE = 256\n",
        "EPOCHS = 300\n",
        "LR = 0.001\n",
        "\n",
        "optimizer = tf.keras.optimizers.Adam()\n",
        "\n",
        "global weight2\n",
        "if train_target == 1: \n",
        "    # only for M\n",
        "    weight2 = np.array([0,0,1,0])\n",
        "else: \n",
        "    # only for V\n",
        "    weight2 = np.array([0,0,0,1])\n",
        "    \n",
        "# if train_target==0:\n",
        "model = build_cnn_model()\n",
        "model.compile(loss=my_loss_E1, optimizer=optimizer)\n",
        "\n",
        "# Find optimal LR \n",
        "lr_finder = LRFinder(min_lr=1e-5, max_lr=1e-1, steps_per_epoch=10, epochs=3)\n",
        "model.fit(X, y, callbacks=[lr_finder])\n",
        "\n",
        "plt.figure()\n",
        "lr_finder.plot_loss()\n",
        "\n",
        "# plt.figure()\n",
        "# lr_finder.plot_lr()\n",
        "\n",
        "del model \n",
        "gc.collect()"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "88/88 [==============================] - 2s 20ms/step - loss: 1.5592\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": [
              "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\n"
            ],
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "execute_result",
          "execution_count": 31,
          "data": {
            "text/plain": [
              "10711"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ],
      "execution_count": 31,
      "metadata": {
        "id": "J4d6cgq2RSSP",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 317
        },
        "outputId": "0664ee2a-b495-4053-e55d-fbd55628cfd1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "train_target = 0\n",
        "\n",
        "LR = 0.01\n",
        "\n",
        "model0 = build_cnn_model()\n",
        "optimizer = tf.keras.optimizers.Adam()\n",
        "optimizer = tfa.optimizers.SWA(optimizer)\n",
        "\n",
        "global weight2\n",
        "if train_target == 1: \n",
        "    # only for M\n",
        "    weight2 = np.array([0,0,1,0])\n",
        "else: \n",
        "    # only for V\n",
        "    weight2 = np.array([0,0,0,1])\n",
        "    \n",
        "model0.compile(loss=my_loss_E1, optimizer=optimizer, metrics=[r2_keras])\n",
        "\n",
        "# callbacks\n",
        "MODEL_PATH = '/content/drive/My Drive/ML Projects/DACON/Colision/'\n",
        "MODEL_NAME = 'CNN_model_3a.h5'      # _epoch{epoch:02d}_loss{val_loss:.2f}\n",
        "\n",
        "es = tf.keras.callbacks.EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=25)\n",
        "mc = tf.keras.callbacks.ModelCheckpoint(MODEL_PATH+MODEL_NAME, monitor='val_loss', save_best_only=True, save_weights_only=False, verbose=1)\n",
        "\n",
        "# select LR schedule Callback\n",
        "# ---------------------------\n",
        "# rlr = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', patience=10, verbose=1, factor=0.7)\n",
        "# lr_schedule = step_decay_schedule(initial_lr=1e-2, decay_factor=0.5, step_size=5)\n",
        "lr_cyclic = CyclicLR(base_lr=0.001, max_lr=0.006, step_size=25., mode='exp_range', gamma=0.99994)\n",
        "# lr_cos = WarmUpCosineDecayScheduler()\n",
        "\n",
        "callbacks=[es,  mc, lr_cyclic]             \n",
        "# lr_cyclic, lr_cos, \n"
      ],
      "outputs": [],
      "execution_count": 91,
      "metadata": {
        "id": "OeGJ7gG0p1fL",
        "colab_type": "code",
        "colab": {}
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print('Train CNN model #3 for X,Y')   # kernel 5 + SWA\n",
        "print()\n",
        "\n",
        "hist0 = model0.fit(X, y,                   \n",
        "                 validation_split=0.2,    \n",
        "                 batch_size=BATCH_SIZE,\n",
        "                 epochs=EPOCHS,\n",
        "                 verbose=1,\n",
        "                 shuffle=True,\n",
        "                 callbacks=callbacks)"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Train CNN model #3 for X,Y\n",
            "\n",
            "Epoch 1/200\n",
            "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/resource_variable_ops.py:1817: calling BaseResourceVariable.__init__ (from tensorflow.python.ops.resource_variable_ops) with constraint is deprecated and will be removed in a future version.\n",
            "Instructions for updating:\n",
            "If using Keras pass *_constraint arguments to layers.\n",
            "9/9 [==============================] - ETA: 0s - loss: 1.6620 - r2_keras: -0.0149\n",
            "Epoch 00001: val_loss improved from inf to 1.64005, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3a.h5\n",
            "9/9 [==============================] - 4s 402ms/step - loss: 1.6620 - r2_keras: -0.0149 - val_loss: 1.6401 - val_r2_keras: -0.0083\n",
            "Epoch 2/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 1.4930 - r2_keras: 0.0826\n",
            "Epoch 00002: val_loss improved from 1.64005 to 0.90145, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3a.h5\n",
            "9/9 [==============================] - 1s 135ms/step - loss: 1.4930 - r2_keras: 0.0826 - val_loss: 0.9015 - val_r2_keras: 0.3942\n",
            "Epoch 3/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.5099 - r2_keras: 0.5989\n",
            "Epoch 00003: val_loss did not improve from 0.90145\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.5099 - r2_keras: 0.5989 - val_loss: 18.0675 - val_r2_keras: -9.3360\n",
            "Epoch 4/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.2123 - r2_keras: 0.7649\n",
            "Epoch 00004: val_loss did not improve from 0.90145\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.2123 - r2_keras: 0.7649 - val_loss: 29.3390 - val_r2_keras: -15.4598\n",
            "Epoch 5/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1670 - r2_keras: 0.7962\n",
            "Epoch 00005: val_loss did not improve from 0.90145\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.1670 - r2_keras: 0.7962 - val_loss: 18.3971 - val_r2_keras: -9.4430\n",
            "Epoch 6/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1525 - r2_keras: 0.8047\n",
            "Epoch 00006: val_loss did not improve from 0.90145\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.1525 - r2_keras: 0.8047 - val_loss: 5.9784 - val_r2_keras: -2.5028\n",
            "Epoch 7/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1480 - r2_keras: 0.8080\n",
            "Epoch 00007: val_loss did not improve from 0.90145\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.1480 - r2_keras: 0.8080 - val_loss: 4.1563 - val_r2_keras: -1.4999\n",
            "Epoch 8/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1412 - r2_keras: 0.8119\n",
            "Epoch 00008: val_loss did not improve from 0.90145\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.1412 - r2_keras: 0.8119 - val_loss: 2.2800 - val_r2_keras: -0.4429\n",
            "Epoch 9/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1439 - r2_keras: 0.8095\n",
            "Epoch 00009: val_loss did not improve from 0.90145\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1439 - r2_keras: 0.8095 - val_loss: 1.2176 - val_r2_keras: 0.1801\n",
            "Epoch 10/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1431 - r2_keras: 0.8115\n",
            "Epoch 00010: val_loss improved from 0.90145 to 0.79007, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3a.h5\n",
            "9/9 [==============================] - 1s 125ms/step - loss: 0.1431 - r2_keras: 0.8115 - val_loss: 0.7901 - val_r2_keras: 0.4119\n",
            "Epoch 11/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1382 - r2_keras: 0.8128\n",
            "Epoch 00011: val_loss improved from 0.79007 to 0.27100, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3a.h5\n",
            "9/9 [==============================] - 1s 122ms/step - loss: 0.1382 - r2_keras: 0.8128 - val_loss: 0.2710 - val_r2_keras: 0.7259\n",
            "Epoch 12/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1408 - r2_keras: 0.8125\n",
            "Epoch 00012: val_loss improved from 0.27100 to 0.21639, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3a.h5\n",
            "9/9 [==============================] - 1s 123ms/step - loss: 0.1408 - r2_keras: 0.8125 - val_loss: 0.2164 - val_r2_keras: 0.7625\n",
            "Epoch 13/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1415 - r2_keras: 0.8116\n",
            "Epoch 00013: val_loss improved from 0.21639 to 0.12384, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3a.h5\n",
            "9/9 [==============================] - 1s 123ms/step - loss: 0.1415 - r2_keras: 0.8116 - val_loss: 0.1238 - val_r2_keras: 0.8146\n",
            "Epoch 14/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1452 - r2_keras: 0.8097\n",
            "Epoch 00014: val_loss improved from 0.12384 to 0.08354, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3a.h5\n",
            "9/9 [==============================] - 1s 124ms/step - loss: 0.1452 - r2_keras: 0.8097 - val_loss: 0.0835 - val_r2_keras: 0.8373\n",
            "Epoch 15/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1348 - r2_keras: 0.8147\n",
            "Epoch 00015: val_loss did not improve from 0.08354\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.1348 - r2_keras: 0.8147 - val_loss: 0.1023 - val_r2_keras: 0.8302\n",
            "Epoch 16/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1408 - r2_keras: 0.8086\n",
            "Epoch 00016: val_loss improved from 0.08354 to 0.03345, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3a.h5\n",
            "9/9 [==============================] - 1s 123ms/step - loss: 0.1408 - r2_keras: 0.8086 - val_loss: 0.0334 - val_r2_keras: 0.8668\n",
            "Epoch 17/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1339 - r2_keras: 0.8125\n",
            "Epoch 00017: val_loss did not improve from 0.03345\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.1339 - r2_keras: 0.8125 - val_loss: 0.0516 - val_r2_keras: 0.8571\n",
            "Epoch 18/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1393 - r2_keras: 0.8105\n",
            "Epoch 00018: val_loss did not improve from 0.03345\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1393 - r2_keras: 0.8105 - val_loss: 0.1025 - val_r2_keras: 0.8361\n",
            "Epoch 19/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1477 - r2_keras: 0.8046\n",
            "Epoch 00019: val_loss did not improve from 0.03345\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.1477 - r2_keras: 0.8046 - val_loss: 0.2385 - val_r2_keras: 0.7660\n",
            "Epoch 20/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1369 - r2_keras: 0.8142\n",
            "Epoch 00020: val_loss did not improve from 0.03345\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.1369 - r2_keras: 0.8142 - val_loss: 0.2540 - val_r2_keras: 0.7580\n",
            "Epoch 21/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1425 - r2_keras: 0.8114\n",
            "Epoch 00021: val_loss did not improve from 0.03345\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.1425 - r2_keras: 0.8114 - val_loss: 0.1929 - val_r2_keras: 0.7916\n",
            "Epoch 22/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1316 - r2_keras: 0.8181\n",
            "Epoch 00022: val_loss did not improve from 0.03345\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1316 - r2_keras: 0.8181 - val_loss: 0.0689 - val_r2_keras: 0.8566\n",
            "Epoch 23/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1282 - r2_keras: 0.8195\n",
            "Epoch 00023: val_loss did not improve from 0.03345\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1282 - r2_keras: 0.8195 - val_loss: 0.1131 - val_r2_keras: 0.8352\n",
            "Epoch 24/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1373 - r2_keras: 0.8148\n",
            "Epoch 00024: val_loss did not improve from 0.03345\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1373 - r2_keras: 0.8148 - val_loss: 0.2865 - val_r2_keras: 0.7422\n",
            "Epoch 25/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1359 - r2_keras: 0.8150\n",
            "Epoch 00025: val_loss did not improve from 0.03345\n",
            "9/9 [==============================] - 1s 99ms/step - loss: 0.1359 - r2_keras: 0.8150 - val_loss: 0.2284 - val_r2_keras: 0.7719\n",
            "Epoch 26/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1422 - r2_keras: 0.8092\n",
            "Epoch 00026: val_loss did not improve from 0.03345\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.1422 - r2_keras: 0.8092 - val_loss: 0.1678 - val_r2_keras: 0.8043\n",
            "Epoch 27/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1374 - r2_keras: 0.8107\n",
            "Epoch 00027: val_loss did not improve from 0.03345\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1374 - r2_keras: 0.8107 - val_loss: 0.2751 - val_r2_keras: 0.7467\n",
            "Epoch 28/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1421 - r2_keras: 0.8077\n",
            "Epoch 00028: val_loss did not improve from 0.03345\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.1421 - r2_keras: 0.8077 - val_loss: 0.4066 - val_r2_keras: 0.6758\n",
            "Epoch 29/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1284 - r2_keras: 0.8171\n",
            "Epoch 00029: val_loss did not improve from 0.03345\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1284 - r2_keras: 0.8171 - val_loss: 0.1102 - val_r2_keras: 0.8342\n",
            "Epoch 30/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1346 - r2_keras: 0.8135\n",
            "Epoch 00030: val_loss improved from 0.03345 to 0.00875, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3a.h5\n",
            "9/9 [==============================] - 3s 318ms/step - loss: 0.1346 - r2_keras: 0.8135 - val_loss: 0.0088 - val_r2_keras: 0.8865\n",
            "Epoch 31/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1389 - r2_keras: 0.8149\n",
            "Epoch 00031: val_loss did not improve from 0.00875\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1389 - r2_keras: 0.8149 - val_loss: 0.1191 - val_r2_keras: 0.8350\n",
            "Epoch 32/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1416 - r2_keras: 0.8134\n",
            "Epoch 00032: val_loss did not improve from 0.00875\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.1416 - r2_keras: 0.8134 - val_loss: 0.2081 - val_r2_keras: 0.7864\n",
            "Epoch 33/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1380 - r2_keras: 0.8143\n",
            "Epoch 00033: val_loss did not improve from 0.00875\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.1380 - r2_keras: 0.8143 - val_loss: 0.0783 - val_r2_keras: 0.8522\n",
            "Epoch 34/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1352 - r2_keras: 0.8146\n",
            "Epoch 00034: val_loss did not improve from 0.00875\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.1352 - r2_keras: 0.8146 - val_loss: 0.0197 - val_r2_keras: 0.8814\n",
            "Epoch 35/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1295 - r2_keras: 0.8171\n",
            "Epoch 00035: val_loss did not improve from 0.00875\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.1295 - r2_keras: 0.8171 - val_loss: 0.0513 - val_r2_keras: 0.8667\n",
            "Epoch 36/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1320 - r2_keras: 0.8167\n",
            "Epoch 00036: val_loss did not improve from 0.00875\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.1320 - r2_keras: 0.8167 - val_loss: 0.0868 - val_r2_keras: 0.8473\n",
            "Epoch 37/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1400 - r2_keras: 0.8099\n",
            "Epoch 00037: val_loss did not improve from 0.00875\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.1400 - r2_keras: 0.8099 - val_loss: 0.0877 - val_r2_keras: 0.8444\n",
            "Epoch 38/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1351 - r2_keras: 0.8080\n",
            "Epoch 00038: val_loss did not improve from 0.00875\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.1351 - r2_keras: 0.8080 - val_loss: 0.0464 - val_r2_keras: 0.8644\n",
            "Epoch 39/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1351 - r2_keras: 0.8105\n",
            "Epoch 00039: val_loss did not improve from 0.00875\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1351 - r2_keras: 0.8105 - val_loss: 0.0819 - val_r2_keras: 0.8456\n",
            "Epoch 40/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1300 - r2_keras: 0.8131\n",
            "Epoch 00040: val_loss did not improve from 0.00875\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1300 - r2_keras: 0.8131 - val_loss: 0.2226 - val_r2_keras: 0.7740\n",
            "Epoch 41/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1287 - r2_keras: 0.8149\n",
            "Epoch 00041: val_loss did not improve from 0.00875\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1287 - r2_keras: 0.8149 - val_loss: 0.0566 - val_r2_keras: 0.8599\n",
            "Epoch 42/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1331 - r2_keras: 0.8128\n",
            "Epoch 00042: val_loss did not improve from 0.00875\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.1331 - r2_keras: 0.8128 - val_loss: 0.4931 - val_r2_keras: 0.6297\n",
            "Epoch 43/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1369 - r2_keras: 0.8122\n",
            "Epoch 00043: val_loss did not improve from 0.00875\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.1369 - r2_keras: 0.8122 - val_loss: 0.0464 - val_r2_keras: 0.8699\n",
            "Epoch 44/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1373 - r2_keras: 0.8138\n",
            "Epoch 00044: val_loss improved from 0.00875 to 0.00665, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3a.h5\n",
            "9/9 [==============================] - 2s 234ms/step - loss: 0.1373 - r2_keras: 0.8138 - val_loss: 0.0067 - val_r2_keras: 0.8845\n",
            "Epoch 45/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1272 - r2_keras: 0.8192\n",
            "Epoch 00045: val_loss improved from 0.00665 to 0.00569, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3a.h5\n",
            "9/9 [==============================] - 1s 123ms/step - loss: 0.1272 - r2_keras: 0.8192 - val_loss: 0.0057 - val_r2_keras: 0.8861\n",
            "Epoch 46/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1288 - r2_keras: 0.8177\n",
            "Epoch 00046: val_loss did not improve from 0.00569\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.1288 - r2_keras: 0.8177 - val_loss: 0.0404 - val_r2_keras: 0.8703\n",
            "Epoch 47/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1295 - r2_keras: 0.8166\n",
            "Epoch 00047: val_loss did not improve from 0.00569\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1295 - r2_keras: 0.8166 - val_loss: 0.0976 - val_r2_keras: 0.8409\n",
            "Epoch 48/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1377 - r2_keras: 0.8125\n",
            "Epoch 00048: val_loss did not improve from 0.00569\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.1377 - r2_keras: 0.8125 - val_loss: 0.1521 - val_r2_keras: 0.8156\n",
            "Epoch 49/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1322 - r2_keras: 0.8172\n",
            "Epoch 00049: val_loss did not improve from 0.00569\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.1322 - r2_keras: 0.8172 - val_loss: 0.0588 - val_r2_keras: 0.8624\n",
            "Epoch 50/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1339 - r2_keras: 0.8165\n",
            "Epoch 00050: val_loss did not improve from 0.00569\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.1339 - r2_keras: 0.8165 - val_loss: 0.0614 - val_r2_keras: 0.8594\n",
            "Epoch 51/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1229 - r2_keras: 0.8202\n",
            "Epoch 00051: val_loss did not improve from 0.00569\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.1229 - r2_keras: 0.8202 - val_loss: 0.0751 - val_r2_keras: 0.8537\n",
            "Epoch 52/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1339 - r2_keras: 0.8163\n",
            "Epoch 00052: val_loss did not improve from 0.00569\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1339 - r2_keras: 0.8163 - val_loss: 0.1464 - val_r2_keras: 0.8183\n",
            "Epoch 53/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1297 - r2_keras: 0.8176\n",
            "Epoch 00053: val_loss did not improve from 0.00569\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.1297 - r2_keras: 0.8176 - val_loss: 0.1331 - val_r2_keras: 0.8244\n",
            "Epoch 54/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1284 - r2_keras: 0.8173\n",
            "Epoch 00054: val_loss did not improve from 0.00569\n",
            "9/9 [==============================] - 1s 99ms/step - loss: 0.1284 - r2_keras: 0.8173 - val_loss: 0.0921 - val_r2_keras: 0.8432\n",
            "Epoch 55/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1321 - r2_keras: 0.8124\n",
            "Epoch 00055: val_loss did not improve from 0.00569\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.1321 - r2_keras: 0.8124 - val_loss: 0.1733 - val_r2_keras: 0.8010\n",
            "Epoch 56/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1283 - r2_keras: 0.8160\n",
            "Epoch 00056: val_loss did not improve from 0.00569\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.1283 - r2_keras: 0.8160 - val_loss: 0.0884 - val_r2_keras: 0.8445\n",
            "Epoch 57/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1241 - r2_keras: 0.8179\n",
            "Epoch 00057: val_loss did not improve from 0.00569\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.1241 - r2_keras: 0.8179 - val_loss: 0.0147 - val_r2_keras: 0.8804\n",
            "Epoch 58/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1293 - r2_keras: 0.8151\n",
            "Epoch 00058: val_loss improved from 0.00569 to 0.00561, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3a.h5\n",
            "9/9 [==============================] - 2s 235ms/step - loss: 0.1293 - r2_keras: 0.8151 - val_loss: 0.0056 - val_r2_keras: 0.8831\n",
            "Epoch 59/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1390 - r2_keras: 0.8103\n",
            "Epoch 00059: val_loss did not improve from 0.00561\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1390 - r2_keras: 0.8103 - val_loss: 0.0330 - val_r2_keras: 0.8736\n",
            "Epoch 60/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1341 - r2_keras: 0.8126\n",
            "Epoch 00060: val_loss did not improve from 0.00561\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1341 - r2_keras: 0.8126 - val_loss: 0.3336 - val_r2_keras: 0.7152\n",
            "Epoch 61/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1271 - r2_keras: 0.8162\n",
            "Epoch 00061: val_loss did not improve from 0.00561\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.1271 - r2_keras: 0.8162 - val_loss: 0.1811 - val_r2_keras: 0.7962\n",
            "Epoch 62/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1336 - r2_keras: 0.8119\n",
            "Epoch 00062: val_loss did not improve from 0.00561\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1336 - r2_keras: 0.8119 - val_loss: 0.0350 - val_r2_keras: 0.8726\n",
            "Epoch 63/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1291 - r2_keras: 0.8166\n",
            "Epoch 00063: val_loss improved from 0.00561 to 0.00514, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3a.h5\n",
            "9/9 [==============================] - 1s 124ms/step - loss: 0.1291 - r2_keras: 0.8166 - val_loss: 0.0051 - val_r2_keras: 0.8860\n",
            "Epoch 64/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1306 - r2_keras: 0.8165\n",
            "Epoch 00064: val_loss did not improve from 0.00514\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1306 - r2_keras: 0.8165 - val_loss: 0.0073 - val_r2_keras: 0.8861\n",
            "Epoch 65/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1357 - r2_keras: 0.8179\n",
            "Epoch 00065: val_loss did not improve from 0.00514\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.1357 - r2_keras: 0.8179 - val_loss: 0.0194 - val_r2_keras: 0.8846\n",
            "Epoch 66/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1257 - r2_keras: 0.8241\n",
            "Epoch 00066: val_loss did not improve from 0.00514\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1257 - r2_keras: 0.8241 - val_loss: 0.1393 - val_r2_keras: 0.8231\n",
            "Epoch 67/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1286 - r2_keras: 0.8208\n",
            "Epoch 00067: val_loss did not improve from 0.00514\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1286 - r2_keras: 0.8208 - val_loss: 0.2942 - val_r2_keras: 0.7378\n",
            "Epoch 68/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1348 - r2_keras: 0.8184\n",
            "Epoch 00068: val_loss did not improve from 0.00514\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.1348 - r2_keras: 0.8184 - val_loss: 0.1428 - val_r2_keras: 0.8193\n",
            "Epoch 69/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1361 - r2_keras: 0.8152\n",
            "Epoch 00069: val_loss did not improve from 0.00514\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1361 - r2_keras: 0.8152 - val_loss: 0.0225 - val_r2_keras: 0.8793\n",
            "Epoch 70/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1301 - r2_keras: 0.8209\n",
            "Epoch 00070: val_loss did not improve from 0.00514\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.1301 - r2_keras: 0.8209 - val_loss: 0.0342 - val_r2_keras: 0.8737\n",
            "Epoch 71/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1329 - r2_keras: 0.8166\n",
            "Epoch 00071: val_loss did not improve from 0.00514\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.1329 - r2_keras: 0.8166 - val_loss: 0.0446 - val_r2_keras: 0.8688\n",
            "Epoch 72/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1294 - r2_keras: 0.8184\n",
            "Epoch 00072: val_loss did not improve from 0.00514\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.1294 - r2_keras: 0.8184 - val_loss: 0.0221 - val_r2_keras: 0.8789\n",
            "Epoch 73/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1275 - r2_keras: 0.8179\n",
            "Epoch 00073: val_loss did not improve from 0.00514\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.1275 - r2_keras: 0.8179 - val_loss: 0.0159 - val_r2_keras: 0.8827\n",
            "Epoch 74/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1383 - r2_keras: 0.8140\n",
            "Epoch 00074: val_loss did not improve from 0.00514\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1383 - r2_keras: 0.8140 - val_loss: 0.0286 - val_r2_keras: 0.8774\n",
            "Epoch 75/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1376 - r2_keras: 0.8133\n",
            "Epoch 00075: val_loss did not improve from 0.00514\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.1376 - r2_keras: 0.8133 - val_loss: 0.0877 - val_r2_keras: 0.8458\n",
            "Epoch 76/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1288 - r2_keras: 0.8174\n",
            "Epoch 00076: val_loss did not improve from 0.00514\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1288 - r2_keras: 0.8174 - val_loss: 0.0209 - val_r2_keras: 0.8800\n",
            "Epoch 77/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1225 - r2_keras: 0.8210\n",
            "Epoch 00077: val_loss did not improve from 0.00514\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1225 - r2_keras: 0.8210 - val_loss: 0.0086 - val_r2_keras: 0.8842\n",
            "Epoch 78/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1241 - r2_keras: 0.8203\n",
            "Epoch 00078: val_loss did not improve from 0.00514\n",
            "9/9 [==============================] - 1s 93ms/step - loss: 0.1241 - r2_keras: 0.8203 - val_loss: 0.0053 - val_r2_keras: 0.8863\n",
            "Epoch 79/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1306 - r2_keras: 0.8156\n",
            "Epoch 00079: val_loss improved from 0.00514 to 0.00502, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3a.h5\n",
            "9/9 [==============================] - 2s 214ms/step - loss: 0.1306 - r2_keras: 0.8156 - val_loss: 0.0050 - val_r2_keras: 0.8879\n",
            "Epoch 80/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1298 - r2_keras: 0.8188\n",
            "Epoch 00080: val_loss did not improve from 0.00502\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.1298 - r2_keras: 0.8188 - val_loss: 0.0065 - val_r2_keras: 0.8888\n",
            "Epoch 81/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1280 - r2_keras: 0.8209\n",
            "Epoch 00081: val_loss did not improve from 0.00502\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1280 - r2_keras: 0.8209 - val_loss: 0.0501 - val_r2_keras: 0.8679\n",
            "Epoch 82/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1401 - r2_keras: 0.8135\n",
            "Epoch 00082: val_loss did not improve from 0.00502\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.1401 - r2_keras: 0.8135 - val_loss: 0.1175 - val_r2_keras: 0.8325\n",
            "Epoch 83/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1247 - r2_keras: 0.8230\n",
            "Epoch 00083: val_loss did not improve from 0.00502\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1247 - r2_keras: 0.8230 - val_loss: 0.0983 - val_r2_keras: 0.8433\n",
            "Epoch 84/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1293 - r2_keras: 0.8191\n",
            "Epoch 00084: val_loss did not improve from 0.00502\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.1293 - r2_keras: 0.8191 - val_loss: 0.0742 - val_r2_keras: 0.8563\n",
            "Epoch 85/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1300 - r2_keras: 0.8201\n",
            "Epoch 00085: val_loss did not improve from 0.00502\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1300 - r2_keras: 0.8201 - val_loss: 0.0297 - val_r2_keras: 0.8787\n",
            "Epoch 86/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1305 - r2_keras: 0.8193\n",
            "Epoch 00086: val_loss did not improve from 0.00502\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.1305 - r2_keras: 0.8193 - val_loss: 0.1660 - val_r2_keras: 0.8070\n",
            "Epoch 87/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1295 - r2_keras: 0.8199\n",
            "Epoch 00087: val_loss did not improve from 0.00502\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1295 - r2_keras: 0.8199 - val_loss: 0.1278 - val_r2_keras: 0.8276\n",
            "Epoch 88/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1253 - r2_keras: 0.8222\n",
            "Epoch 00088: val_loss did not improve from 0.00502\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1253 - r2_keras: 0.8222 - val_loss: 0.0354 - val_r2_keras: 0.8750\n",
            "Epoch 89/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1276 - r2_keras: 0.8213\n",
            "Epoch 00089: val_loss did not improve from 0.00502\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.1276 - r2_keras: 0.8213 - val_loss: 0.0130 - val_r2_keras: 0.8840\n",
            "Epoch 90/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1258 - r2_keras: 0.8214\n",
            "Epoch 00090: val_loss did not improve from 0.00502\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1258 - r2_keras: 0.8214 - val_loss: 0.0207 - val_r2_keras: 0.8820\n",
            "Epoch 91/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1294 - r2_keras: 0.8198\n",
            "Epoch 00091: val_loss did not improve from 0.00502\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1294 - r2_keras: 0.8198 - val_loss: 0.2057 - val_r2_keras: 0.7867\n",
            "Epoch 92/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1350 - r2_keras: 0.8158\n",
            "Epoch 00092: val_loss did not improve from 0.00502\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.1350 - r2_keras: 0.8158 - val_loss: 0.3169 - val_r2_keras: 0.7245\n",
            "Epoch 93/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1335 - r2_keras: 0.8161\n",
            "Epoch 00093: val_loss did not improve from 0.00502\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.1335 - r2_keras: 0.8161 - val_loss: 0.3504 - val_r2_keras: 0.7057\n",
            "Epoch 94/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1360 - r2_keras: 0.8166\n",
            "Epoch 00094: val_loss did not improve from 0.00502\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.1360 - r2_keras: 0.8166 - val_loss: 0.1297 - val_r2_keras: 0.8255\n",
            "Epoch 95/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1245 - r2_keras: 0.8209\n",
            "Epoch 00095: val_loss did not improve from 0.00502\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.1245 - r2_keras: 0.8209 - val_loss: 0.0384 - val_r2_keras: 0.8739\n",
            "Epoch 96/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1278 - r2_keras: 0.8210\n",
            "Epoch 00096: val_loss did not improve from 0.00502\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.1278 - r2_keras: 0.8210 - val_loss: 0.0182 - val_r2_keras: 0.8820\n",
            "Epoch 97/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1350 - r2_keras: 0.8159\n",
            "Epoch 00097: val_loss improved from 0.00502 to 0.00482, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3a.h5\n",
            "9/9 [==============================] - 2s 250ms/step - loss: 0.1350 - r2_keras: 0.8159 - val_loss: 0.0048 - val_r2_keras: 0.8860\n",
            "Epoch 98/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1326 - r2_keras: 0.8162\n",
            "Epoch 00098: val_loss did not improve from 0.00482\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.1326 - r2_keras: 0.8162 - val_loss: 0.0111 - val_r2_keras: 0.8840\n",
            "Epoch 99/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1281 - r2_keras: 0.8168\n",
            "Epoch 00099: val_loss did not improve from 0.00482\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.1281 - r2_keras: 0.8168 - val_loss: 0.0147 - val_r2_keras: 0.8808\n",
            "Epoch 100/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1245 - r2_keras: 0.8217\n",
            "Epoch 00100: val_loss did not improve from 0.00482\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1245 - r2_keras: 0.8217 - val_loss: 0.0075 - val_r2_keras: 0.8866\n",
            "Epoch 101/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1218 - r2_keras: 0.8233\n",
            "Epoch 00101: val_loss improved from 0.00482 to 0.00429, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3a.h5\n",
            "9/9 [==============================] - 1s 124ms/step - loss: 0.1218 - r2_keras: 0.8233 - val_loss: 0.0043 - val_r2_keras: 0.8886\n",
            "Epoch 102/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1277 - r2_keras: 0.8206\n",
            "Epoch 00102: val_loss did not improve from 0.00429\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.1277 - r2_keras: 0.8206 - val_loss: 0.0136 - val_r2_keras: 0.8815\n",
            "Epoch 103/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1285 - r2_keras: 0.8195\n",
            "Epoch 00103: val_loss did not improve from 0.00429\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1285 - r2_keras: 0.8195 - val_loss: 0.0064 - val_r2_keras: 0.8879\n",
            "Epoch 104/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1356 - r2_keras: 0.8160\n",
            "Epoch 00104: val_loss did not improve from 0.00429\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.1356 - r2_keras: 0.8160 - val_loss: 0.0166 - val_r2_keras: 0.8778\n",
            "Epoch 105/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1284 - r2_keras: 0.8215\n",
            "Epoch 00105: val_loss did not improve from 0.00429\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1284 - r2_keras: 0.8215 - val_loss: 0.0138 - val_r2_keras: 0.8808\n",
            "Epoch 106/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1276 - r2_keras: 0.8222\n",
            "Epoch 00106: val_loss improved from 0.00429 to 0.00190, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3a.h5\n",
            "9/9 [==============================] - 1s 123ms/step - loss: 0.1276 - r2_keras: 0.8222 - val_loss: 0.0019 - val_r2_keras: 0.8912\n",
            "Epoch 107/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1385 - r2_keras: 0.8152\n",
            "Epoch 00107: val_loss did not improve from 0.00190\n",
            "9/9 [==============================] - 1s 93ms/step - loss: 0.1385 - r2_keras: 0.8152 - val_loss: 0.0072 - val_r2_keras: 0.8896\n",
            "Epoch 108/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1320 - r2_keras: 0.8184\n",
            "Epoch 00108: val_loss did not improve from 0.00190\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1320 - r2_keras: 0.8184 - val_loss: 0.0147 - val_r2_keras: 0.8874\n",
            "Epoch 109/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1314 - r2_keras: 0.8184\n",
            "Epoch 00109: val_loss did not improve from 0.00190\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1314 - r2_keras: 0.8184 - val_loss: 0.0087 - val_r2_keras: 0.8835\n",
            "Epoch 110/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1280 - r2_keras: 0.8170\n",
            "Epoch 00110: val_loss did not improve from 0.00190\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.1280 - r2_keras: 0.8170 - val_loss: 0.0070 - val_r2_keras: 0.8806\n",
            "Epoch 111/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1329 - r2_keras: 0.8139\n",
            "Epoch 00111: val_loss did not improve from 0.00190\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1329 - r2_keras: 0.8139 - val_loss: 0.0057 - val_r2_keras: 0.8860\n",
            "Epoch 112/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1260 - r2_keras: 0.8185\n",
            "Epoch 00112: val_loss did not improve from 0.00190\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1260 - r2_keras: 0.8185 - val_loss: 0.0298 - val_r2_keras: 0.8767\n",
            "Epoch 113/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1250 - r2_keras: 0.8227\n",
            "Epoch 00113: val_loss did not improve from 0.00190\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1250 - r2_keras: 0.8227 - val_loss: 0.0814 - val_r2_keras: 0.8511\n",
            "Epoch 114/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1301 - r2_keras: 0.8214\n",
            "Epoch 00114: val_loss did not improve from 0.00190\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.1301 - r2_keras: 0.8214 - val_loss: 0.0611 - val_r2_keras: 0.8636\n",
            "Epoch 115/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1364 - r2_keras: 0.8194\n",
            "Epoch 00115: val_loss did not improve from 0.00190\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.1364 - r2_keras: 0.8194 - val_loss: 0.0345 - val_r2_keras: 0.8780\n",
            "Epoch 116/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1291 - r2_keras: 0.8238\n",
            "Epoch 00116: val_loss did not improve from 0.00190\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.1291 - r2_keras: 0.8238 - val_loss: 0.0075 - val_r2_keras: 0.8920\n",
            "Epoch 117/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1300 - r2_keras: 0.8221\n",
            "Epoch 00117: val_loss did not improve from 0.00190\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.1300 - r2_keras: 0.8221 - val_loss: 0.0029 - val_r2_keras: 0.8935\n",
            "Epoch 118/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1296 - r2_keras: 0.8233\n",
            "Epoch 00118: val_loss did not improve from 0.00190\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1296 - r2_keras: 0.8233 - val_loss: 0.0154 - val_r2_keras: 0.8877\n",
            "Epoch 119/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1279 - r2_keras: 0.8221\n",
            "Epoch 00119: val_loss did not improve from 0.00190\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1279 - r2_keras: 0.8221 - val_loss: 0.0046 - val_r2_keras: 0.8884\n",
            "Epoch 120/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1256 - r2_keras: 0.8206\n",
            "Epoch 00120: val_loss did not improve from 0.00190\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1256 - r2_keras: 0.8206 - val_loss: 0.0103 - val_r2_keras: 0.8807\n",
            "Epoch 121/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1304 - r2_keras: 0.8170\n",
            "Epoch 00121: val_loss did not improve from 0.00190\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.1304 - r2_keras: 0.8170 - val_loss: 0.0069 - val_r2_keras: 0.8843\n",
            "Epoch 122/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1285 - r2_keras: 0.8177\n",
            "Epoch 00122: val_loss did not improve from 0.00190\n",
            "9/9 [==============================] - 1s 93ms/step - loss: 0.1285 - r2_keras: 0.8177 - val_loss: 0.0094 - val_r2_keras: 0.8828\n",
            "Epoch 123/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1267 - r2_keras: 0.8215\n",
            "Epoch 00123: val_loss did not improve from 0.00190\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.1267 - r2_keras: 0.8215 - val_loss: 0.0039 - val_r2_keras: 0.8885\n",
            "Epoch 124/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1266 - r2_keras: 0.8180\n",
            "Epoch 00124: val_loss did not improve from 0.00190\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1266 - r2_keras: 0.8180 - val_loss: 0.0114 - val_r2_keras: 0.8839\n",
            "Epoch 125/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1205 - r2_keras: 0.8224\n",
            "Epoch 00125: val_loss did not improve from 0.00190\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.1205 - r2_keras: 0.8224 - val_loss: 0.0098 - val_r2_keras: 0.8848\n",
            "Epoch 126/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1347 - r2_keras: 0.8166\n",
            "Epoch 00126: val_loss did not improve from 0.00190\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.1347 - r2_keras: 0.8166 - val_loss: 0.0112 - val_r2_keras: 0.8877\n",
            "Epoch 127/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1296 - r2_keras: 0.8190\n",
            "Epoch 00127: val_loss did not improve from 0.00190\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.1296 - r2_keras: 0.8190 - val_loss: 0.0672 - val_r2_keras: 0.8588\n",
            "Epoch 128/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1339 - r2_keras: 0.8175\n",
            "Epoch 00128: val_loss did not improve from 0.00190\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.1339 - r2_keras: 0.8175 - val_loss: 0.0371 - val_r2_keras: 0.8748\n",
            "Epoch 129/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1230 - r2_keras: 0.8223\n",
            "Epoch 00129: val_loss did not improve from 0.00190\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1230 - r2_keras: 0.8223 - val_loss: 0.0305 - val_r2_keras: 0.8781\n",
            "Epoch 130/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1358 - r2_keras: 0.8161\n",
            "Epoch 00130: val_loss did not improve from 0.00190\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.1358 - r2_keras: 0.8161 - val_loss: 0.0081 - val_r2_keras: 0.8877\n",
            "Epoch 131/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1272 - r2_keras: 0.8209\n",
            "Epoch 00131: val_loss did not improve from 0.00190\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.1272 - r2_keras: 0.8209 - val_loss: 0.0099 - val_r2_keras: 0.8893\n",
            "Epoch 00131: early stopping\n"
          ]
        }
      ],
      "execution_count": 92,
      "metadata": {
        "id": "7x_N_iAqqbLt",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "2d687b5d-1bb4-4540-9d12-f340fef3af94"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "hist0_df =pd.DataFrame(hist0.history)\n",
        "\n",
        "fig, ax = plt.subplots(1,2, figsize=(10, 4))\n",
        "hist0_df[['loss', 'val_loss']].plot(ax=ax[0])\n",
        "hist0_df[['r2_keras', 'val_r2_keras']].plot(ax=ax[1])\n",
        "ax[1].set_ylim([0.0, 1.0])\n",
        "ax[0].set_ylim([0.0, 2.0])\n",
        "# hist0_df.columns.tolist()"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 93,
          "data": {
            "text/plain": [
              "(0.0, 2.0)"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": [
              "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\n"
            ],
            "text/plain": [
              "<Figure size 720x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ],
      "execution_count": 93,
      "metadata": {
        "id": "QUobZUm5tkoR",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 286
        },
        "outputId": "40abe446-3b8b-437f-ca4e-5cd955e8d64c"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "hist0_df[['val_loss']].min(), np.argmin(hist0_df[['val_loss']])"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 94,
          "data": {
            "text/plain": [
              "(val_loss    0.001897\n",
              " dtype: float64, 105)"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ],
      "execution_count": 94,
      "metadata": {
        "id": "auQaZClFRAnI",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "9959db31-82a8-4b6b-dff9-87c050e33b53"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# model0_cp = tf.keras.models.load_model(MODEL_PATH+'CNN_model_2a.h5')\n",
        "# y_pred_valid = model0_cp.predict(x_valid)"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "id": "1sDZKhWDLQGi",
        "colab_type": "code",
        "colab": {}
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "CNN Model 2\n",
        "\n",
        "Adam + cyclic lr exp(0.001-0.006)  val_loss = 0.002392"
      ],
      "metadata": {
        "id": "cO7bXPCgTeNj",
        "colab_type": "text"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Model #2: Train for M "
      ],
      "metadata": {
        "id": "GxtVdIXpUQva",
        "colab_type": "text"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "train_target = 1\n",
        "\n",
        "# compile model\n",
        "BATCH_SIZE = 256\n",
        "EPOCHS = 200\n",
        "LR = 0.001\n",
        "\n",
        "model1 = build_cnn_model()\n",
        "# model1 = build_wavenet()\n",
        "\n",
        "optimizer = tf.keras.optimizers.Adam()\n",
        "optimizer = tfa.optimizers.SWA(optimizer)\n",
        "\n",
        "global weight2\n",
        "if train_target == 1: \n",
        "    # only for M\n",
        "    weight2 = np.array([0,0,1,0])\n",
        "else: \n",
        "    # only for V\n",
        "    weight2 = np.array([0,0,0,1])\n",
        "    \n",
        "model1.compile(loss=my_loss_E2, optimizer=optimizer)   # metrics=   [r2_keras]tf.keras.metrics.MAPE\n",
        "\n",
        "\n",
        "# callbacks\n",
        "MODEL_PATH = '/content/drive/My Drive/ML Projects/DACON/Colision/'\n",
        "MODEL_NAME = 'CNN_model_3b.h5'      # _epoch{epoch:02d}_loss{val_loss:.2f}\n",
        "\n",
        "es = tf.keras.callbacks.EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=25)\n",
        "mc = tf.keras.callbacks.ModelCheckpoint(MODEL_PATH+MODEL_NAME, monitor='val_loss', save_best_only=True, save_weights_only=False, verbose=1)\n",
        "\n",
        "# select LR schedule Callback\n",
        "# ---------------------------\n",
        "# rlr = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', patience=10, verbose=1, factor=0.7)\n",
        "# lr_schedule = step_decay_schedule(initial_lr=1e-2, decay_factor=0.5, step_size=5)\n",
        "lr_cyclic = CyclicLR(base_lr=0.001, max_lr=0.006, step_size=25., mode='exp_range', gamma=0.99994)\n",
        "# lr_cos = WarmUpCosineDecayScheduler()\n",
        "\n",
        "callbacks=[es, mc, lr_cyclic]             \n",
        "# , rlr, lr_cos, lr_cyclic\n"
      ],
      "outputs": [],
      "execution_count": 100,
      "metadata": {
        "id": "R3h6eWFIUHUY",
        "colab_type": "code",
        "colab": {}
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print('Train CNN Model #3 for M')\n",
        "print()\n",
        "\n",
        "hist1 = model1.fit(X, y,                \n",
        "                 validation_split=0.2,     \n",
        "                 batch_size=BATCH_SIZE,\n",
        "                 epochs=EPOCHS,\n",
        "                 verbose=1,\n",
        "                 shuffle=True,\n",
        "                 callbacks=callbacks)"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Train CNN Model #3 for M\n",
            "\n",
            "Epoch 1/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.2471 - mean_absolute_percentage_error: 4354997.5000\n",
            "Epoch 00001: val_loss improved from inf to 0.24242, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3b.h5\n",
            "9/9 [==============================] - 3s 320ms/step - loss: 0.2471 - mean_absolute_percentage_error: 4354997.5000 - val_loss: 0.2424 - val_mean_absolute_percentage_error: 7538326.5000\n",
            "Epoch 2/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.1677 - mean_absolute_percentage_error: 91567928.0000\n",
            "Epoch 00002: val_loss did not improve from 0.24242\n",
            "9/9 [==============================] - 1s 98ms/step - loss: 0.1677 - mean_absolute_percentage_error: 91567928.0000 - val_loss: 0.6979 - val_mean_absolute_percentage_error: 660526912.0000\n",
            "Epoch 3/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0454 - mean_absolute_percentage_error: 351588864.0000\n",
            "Epoch 00003: val_loss did not improve from 0.24242\n",
            "9/9 [==============================] - 1s 101ms/step - loss: 0.0454 - mean_absolute_percentage_error: 351588864.0000 - val_loss: 6.8025 - val_mean_absolute_percentage_error: 2118944384.0000\n",
            "Epoch 4/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0266 - mean_absolute_percentage_error: 381344416.0000\n",
            "Epoch 00004: val_loss did not improve from 0.24242\n",
            "9/9 [==============================] - 1s 99ms/step - loss: 0.0266 - mean_absolute_percentage_error: 381344416.0000 - val_loss: 11.3083 - val_mean_absolute_percentage_error: 2488306944.0000\n",
            "Epoch 5/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0175 - mean_absolute_percentage_error: 361557568.0000\n",
            "Epoch 00005: val_loss did not improve from 0.24242\n",
            "9/9 [==============================] - 1s 100ms/step - loss: 0.0175 - mean_absolute_percentage_error: 361557568.0000 - val_loss: 8.1665 - val_mean_absolute_percentage_error: 1966257408.0000\n",
            "Epoch 6/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0164 - mean_absolute_percentage_error: 348128096.0000\n",
            "Epoch 00006: val_loss did not improve from 0.24242\n",
            "9/9 [==============================] - 1s 98ms/step - loss: 0.0164 - mean_absolute_percentage_error: 348128096.0000 - val_loss: 3.0997 - val_mean_absolute_percentage_error: 1331858304.0000\n",
            "Epoch 7/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0164 - mean_absolute_percentage_error: 335638944.0000\n",
            "Epoch 00007: val_loss did not improve from 0.24242\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0164 - mean_absolute_percentage_error: 335638944.0000 - val_loss: 2.2311 - val_mean_absolute_percentage_error: 1108427776.0000\n",
            "Epoch 8/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0150 - mean_absolute_percentage_error: 359380608.0000\n",
            "Epoch 00008: val_loss did not improve from 0.24242\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0150 - mean_absolute_percentage_error: 359380608.0000 - val_loss: 1.3669 - val_mean_absolute_percentage_error: 934538496.0000\n",
            "Epoch 9/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0163 - mean_absolute_percentage_error: 329511936.0000\n",
            "Epoch 00009: val_loss did not improve from 0.24242\n",
            "9/9 [==============================] - 1s 98ms/step - loss: 0.0163 - mean_absolute_percentage_error: 329511936.0000 - val_loss: 0.7138 - val_mean_absolute_percentage_error: 766857216.0000\n",
            "Epoch 10/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0149 - mean_absolute_percentage_error: 341367200.0000\n",
            "Epoch 00010: val_loss did not improve from 0.24242\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0149 - mean_absolute_percentage_error: 341367200.0000 - val_loss: 0.3021 - val_mean_absolute_percentage_error: 611414144.0000\n",
            "Epoch 11/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0152 - mean_absolute_percentage_error: 342213120.0000\n",
            "Epoch 00011: val_loss improved from 0.24242 to 0.21238, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3b.h5\n",
            "9/9 [==============================] - 1s 128ms/step - loss: 0.0152 - mean_absolute_percentage_error: 342213120.0000 - val_loss: 0.2124 - val_mean_absolute_percentage_error: 549632000.0000\n",
            "Epoch 12/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0159 - mean_absolute_percentage_error: 351804800.0000\n",
            "Epoch 00012: val_loss improved from 0.21238 to 0.09166, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3b.h5\n",
            "9/9 [==============================] - 1s 127ms/step - loss: 0.0159 - mean_absolute_percentage_error: 351804800.0000 - val_loss: 0.0917 - val_mean_absolute_percentage_error: 469808064.0000\n",
            "Epoch 13/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0153 - mean_absolute_percentage_error: 333715136.0000\n",
            "Epoch 00013: val_loss improved from 0.09166 to 0.08811, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3b.h5\n",
            "9/9 [==============================] - 1s 126ms/step - loss: 0.0153 - mean_absolute_percentage_error: 333715136.0000 - val_loss: 0.0881 - val_mean_absolute_percentage_error: 441233696.0000\n",
            "Epoch 14/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0164 - mean_absolute_percentage_error: 340621056.0000\n",
            "Epoch 00014: val_loss improved from 0.08811 to 0.08436, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3b.h5\n",
            "9/9 [==============================] - 1s 127ms/step - loss: 0.0164 - mean_absolute_percentage_error: 340621056.0000 - val_loss: 0.0844 - val_mean_absolute_percentage_error: 433991040.0000\n",
            "Epoch 15/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0169 - mean_absolute_percentage_error: 347829088.0000\n",
            "Epoch 00015: val_loss improved from 0.08436 to 0.04799, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3b.h5\n",
            "9/9 [==============================] - 1s 129ms/step - loss: 0.0169 - mean_absolute_percentage_error: 347829088.0000 - val_loss: 0.0480 - val_mean_absolute_percentage_error: 402893984.0000\n",
            "Epoch 16/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0154 - mean_absolute_percentage_error: 342056640.0000\n",
            "Epoch 00016: val_loss improved from 0.04799 to 0.04013, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3b.h5\n",
            "9/9 [==============================] - 1s 135ms/step - loss: 0.0154 - mean_absolute_percentage_error: 342056640.0000 - val_loss: 0.0401 - val_mean_absolute_percentage_error: 372479488.0000\n",
            "Epoch 17/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0158 - mean_absolute_percentage_error: 327037568.0000\n",
            "Epoch 00017: val_loss improved from 0.04013 to 0.01133, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3b.h5\n",
            "9/9 [==============================] - 1s 139ms/step - loss: 0.0158 - mean_absolute_percentage_error: 327037568.0000 - val_loss: 0.0113 - val_mean_absolute_percentage_error: 332637472.0000\n",
            "Epoch 18/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0156 - mean_absolute_percentage_error: 346768800.0000\n",
            "Epoch 00018: val_loss did not improve from 0.01133\n",
            "9/9 [==============================] - 1s 98ms/step - loss: 0.0156 - mean_absolute_percentage_error: 346768800.0000 - val_loss: 0.0114 - val_mean_absolute_percentage_error: 327140960.0000\n",
            "Epoch 19/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0160 - mean_absolute_percentage_error: 349500960.0000\n",
            "Epoch 00019: val_loss improved from 0.01133 to 0.00253, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3b.h5\n",
            "9/9 [==============================] - 1s 143ms/step - loss: 0.0160 - mean_absolute_percentage_error: 349500960.0000 - val_loss: 0.0025 - val_mean_absolute_percentage_error: 286964896.0000\n",
            "Epoch 20/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0144 - mean_absolute_percentage_error: 334833440.0000\n",
            "Epoch 00020: val_loss improved from 0.00253 to 0.00192, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3b.h5\n",
            "9/9 [==============================] - 1s 131ms/step - loss: 0.0144 - mean_absolute_percentage_error: 334833440.0000 - val_loss: 0.0019 - val_mean_absolute_percentage_error: 299264448.0000\n",
            "Epoch 21/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0154 - mean_absolute_percentage_error: 334758016.0000\n",
            "Epoch 00021: val_loss did not improve from 0.00192\n",
            "9/9 [==============================] - 1s 98ms/step - loss: 0.0154 - mean_absolute_percentage_error: 334758016.0000 - val_loss: 0.0026 - val_mean_absolute_percentage_error: 296043136.0000\n",
            "Epoch 22/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0149 - mean_absolute_percentage_error: 325399936.0000\n",
            "Epoch 00022: val_loss did not improve from 0.00192\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0149 - mean_absolute_percentage_error: 325399936.0000 - val_loss: 0.0033 - val_mean_absolute_percentage_error: 302485728.0000\n",
            "Epoch 23/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0149 - mean_absolute_percentage_error: 351875360.0000\n",
            "Epoch 00023: val_loss did not improve from 0.00192\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0149 - mean_absolute_percentage_error: 351875360.0000 - val_loss: 0.0023 - val_mean_absolute_percentage_error: 297473984.0000\n",
            "Epoch 24/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0148 - mean_absolute_percentage_error: 344617696.0000\n",
            "Epoch 00024: val_loss did not improve from 0.00192\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0148 - mean_absolute_percentage_error: 344617696.0000 - val_loss: 0.0067 - val_mean_absolute_percentage_error: 312781952.0000\n",
            "Epoch 25/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0147 - mean_absolute_percentage_error: 361638624.0000\n",
            "Epoch 00025: val_loss improved from 0.00192 to 0.00114, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3b.h5\n",
            "9/9 [==============================] - 1s 126ms/step - loss: 0.0147 - mean_absolute_percentage_error: 361638624.0000 - val_loss: 0.0011 - val_mean_absolute_percentage_error: 289775776.0000\n",
            "Epoch 26/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0144 - mean_absolute_percentage_error: 334201856.0000\n",
            "Epoch 00026: val_loss did not improve from 0.00114\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0144 - mean_absolute_percentage_error: 334201856.0000 - val_loss: 0.0017 - val_mean_absolute_percentage_error: 270413440.0000\n",
            "Epoch 27/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0147 - mean_absolute_percentage_error: 314459168.0000\n",
            "Epoch 00027: val_loss did not improve from 0.00114\n",
            "9/9 [==============================] - 1s 99ms/step - loss: 0.0147 - mean_absolute_percentage_error: 314459168.0000 - val_loss: 0.0032 - val_mean_absolute_percentage_error: 279442976.0000\n",
            "Epoch 28/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0140 - mean_absolute_percentage_error: 375359520.0000\n",
            "Epoch 00028: val_loss improved from 0.00114 to 0.00095, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3b.h5\n",
            "9/9 [==============================] - 1s 126ms/step - loss: 0.0140 - mean_absolute_percentage_error: 375359520.0000 - val_loss: 9.4887e-04 - val_mean_absolute_percentage_error: 297554304.0000\n",
            "Epoch 29/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0137 - mean_absolute_percentage_error: 359191776.0000\n",
            "Epoch 00029: val_loss improved from 0.00095 to 0.00086, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3b.h5\n",
            "9/9 [==============================] - 1s 127ms/step - loss: 0.0137 - mean_absolute_percentage_error: 359191776.0000 - val_loss: 8.6182e-04 - val_mean_absolute_percentage_error: 288058368.0000\n",
            "Epoch 30/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0137 - mean_absolute_percentage_error: 348145760.0000\n",
            "Epoch 00030: val_loss did not improve from 0.00086\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0137 - mean_absolute_percentage_error: 348145760.0000 - val_loss: 0.0038 - val_mean_absolute_percentage_error: 315015360.0000\n",
            "Epoch 31/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0153 - mean_absolute_percentage_error: 360123936.0000\n",
            "Epoch 00031: val_loss did not improve from 0.00086\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0153 - mean_absolute_percentage_error: 360123936.0000 - val_loss: 0.0052 - val_mean_absolute_percentage_error: 258022960.0000\n",
            "Epoch 32/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0163 - mean_absolute_percentage_error: 344704384.0000\n",
            "Epoch 00032: val_loss did not improve from 0.00086\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0163 - mean_absolute_percentage_error: 344704384.0000 - val_loss: 0.0067 - val_mean_absolute_percentage_error: 277604256.0000\n",
            "Epoch 33/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0143 - mean_absolute_percentage_error: 352597504.0000\n",
            "Epoch 00033: val_loss did not improve from 0.00086\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0143 - mean_absolute_percentage_error: 352597504.0000 - val_loss: 0.0023 - val_mean_absolute_percentage_error: 292579392.0000\n",
            "Epoch 34/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0133 - mean_absolute_percentage_error: 381081120.0000\n",
            "Epoch 00034: val_loss did not improve from 0.00086\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0133 - mean_absolute_percentage_error: 381081120.0000 - val_loss: 0.0022 - val_mean_absolute_percentage_error: 284436064.0000\n",
            "Epoch 35/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0134 - mean_absolute_percentage_error: 333788416.0000\n",
            "Epoch 00035: val_loss did not improve from 0.00086\n",
            "9/9 [==============================] - 1s 99ms/step - loss: 0.0134 - mean_absolute_percentage_error: 333788416.0000 - val_loss: 0.0034 - val_mean_absolute_percentage_error: 295955840.0000\n",
            "Epoch 36/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0133 - mean_absolute_percentage_error: 334262176.0000\n",
            "Epoch 00036: val_loss improved from 0.00086 to 0.00078, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3b.h5\n",
            "9/9 [==============================] - 1s 127ms/step - loss: 0.0133 - mean_absolute_percentage_error: 334262176.0000 - val_loss: 7.7602e-04 - val_mean_absolute_percentage_error: 303902720.0000\n",
            "Epoch 37/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0135 - mean_absolute_percentage_error: 344650464.0000\n",
            "Epoch 00037: val_loss did not improve from 0.00078\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0135 - mean_absolute_percentage_error: 344650464.0000 - val_loss: 0.0016 - val_mean_absolute_percentage_error: 295066752.0000\n",
            "Epoch 38/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0142 - mean_absolute_percentage_error: 335058304.0000\n",
            "Epoch 00038: val_loss did not improve from 0.00078\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0142 - mean_absolute_percentage_error: 335058304.0000 - val_loss: 0.0012 - val_mean_absolute_percentage_error: 304016672.0000\n",
            "Epoch 39/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0127 - mean_absolute_percentage_error: 337640064.0000\n",
            "Epoch 00039: val_loss did not improve from 0.00078\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0127 - mean_absolute_percentage_error: 337640064.0000 - val_loss: 9.4559e-04 - val_mean_absolute_percentage_error: 292199008.0000\n",
            "Epoch 40/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0138 - mean_absolute_percentage_error: 363273952.0000\n",
            "Epoch 00040: val_loss did not improve from 0.00078\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0138 - mean_absolute_percentage_error: 363273952.0000 - val_loss: 0.0025 - val_mean_absolute_percentage_error: 276290464.0000\n",
            "Epoch 41/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0133 - mean_absolute_percentage_error: 334708160.0000\n",
            "Epoch 00041: val_loss did not improve from 0.00078\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0133 - mean_absolute_percentage_error: 334708160.0000 - val_loss: 0.0030 - val_mean_absolute_percentage_error: 260506736.0000\n",
            "Epoch 42/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0141 - mean_absolute_percentage_error: 353980032.0000\n",
            "Epoch 00042: val_loss did not improve from 0.00078\n",
            "9/9 [==============================] - 1s 98ms/step - loss: 0.0141 - mean_absolute_percentage_error: 353980032.0000 - val_loss: 0.0133 - val_mean_absolute_percentage_error: 345527168.0000\n",
            "Epoch 43/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0142 - mean_absolute_percentage_error: 324890656.0000\n",
            "Epoch 00043: val_loss did not improve from 0.00078\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0142 - mean_absolute_percentage_error: 324890656.0000 - val_loss: 0.0147 - val_mean_absolute_percentage_error: 364884064.0000\n",
            "Epoch 44/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0149 - mean_absolute_percentage_error: 354924512.0000\n",
            "Epoch 00044: val_loss did not improve from 0.00078\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0149 - mean_absolute_percentage_error: 354924512.0000 - val_loss: 0.0065 - val_mean_absolute_percentage_error: 328763680.0000\n",
            "Epoch 45/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0137 - mean_absolute_percentage_error: 350847200.0000\n",
            "Epoch 00045: val_loss did not improve from 0.00078\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0137 - mean_absolute_percentage_error: 350847200.0000 - val_loss: 0.0021 - val_mean_absolute_percentage_error: 313747872.0000\n",
            "Epoch 46/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0140 - mean_absolute_percentage_error: 325826688.0000\n",
            "Epoch 00046: val_loss did not improve from 0.00078\n",
            "9/9 [==============================] - 1s 98ms/step - loss: 0.0140 - mean_absolute_percentage_error: 325826688.0000 - val_loss: 0.0024 - val_mean_absolute_percentage_error: 285400896.0000\n",
            "Epoch 47/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0133 - mean_absolute_percentage_error: 312677536.0000\n",
            "Epoch 00047: val_loss did not improve from 0.00078\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0133 - mean_absolute_percentage_error: 312677536.0000 - val_loss: 0.0051 - val_mean_absolute_percentage_error: 239116080.0000\n",
            "Epoch 48/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0133 - mean_absolute_percentage_error: 341661120.0000\n",
            "Epoch 00048: val_loss did not improve from 0.00078\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0133 - mean_absolute_percentage_error: 341661120.0000 - val_loss: 0.0107 - val_mean_absolute_percentage_error: 243262400.0000\n",
            "Epoch 49/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0121 - mean_absolute_percentage_error: 322178944.0000\n",
            "Epoch 00049: val_loss did not improve from 0.00078\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0121 - mean_absolute_percentage_error: 322178944.0000 - val_loss: 0.0135 - val_mean_absolute_percentage_error: 253885616.0000\n",
            "Epoch 50/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0130 - mean_absolute_percentage_error: 345835584.0000\n",
            "Epoch 00050: val_loss did not improve from 0.00078\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0130 - mean_absolute_percentage_error: 345835584.0000 - val_loss: 0.0101 - val_mean_absolute_percentage_error: 244555280.0000\n",
            "Epoch 51/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0126 - mean_absolute_percentage_error: 328317984.0000\n",
            "Epoch 00051: val_loss did not improve from 0.00078\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0126 - mean_absolute_percentage_error: 328317984.0000 - val_loss: 0.0038 - val_mean_absolute_percentage_error: 271451808.0000\n",
            "Epoch 52/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0125 - mean_absolute_percentage_error: 340567168.0000\n",
            "Epoch 00052: val_loss did not improve from 0.00078\n",
            "9/9 [==============================] - 1s 98ms/step - loss: 0.0125 - mean_absolute_percentage_error: 340567168.0000 - val_loss: 0.0019 - val_mean_absolute_percentage_error: 275575936.0000\n",
            "Epoch 53/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0125 - mean_absolute_percentage_error: 305322560.0000\n",
            "Epoch 00053: val_loss improved from 0.00078 to 0.00071, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3b.h5\n",
            "9/9 [==============================] - 2s 262ms/step - loss: 0.0125 - mean_absolute_percentage_error: 305322560.0000 - val_loss: 7.0633e-04 - val_mean_absolute_percentage_error: 297755456.0000\n",
            "Epoch 54/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0131 - mean_absolute_percentage_error: 341597088.0000\n",
            "Epoch 00054: val_loss did not improve from 0.00071\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0131 - mean_absolute_percentage_error: 341597088.0000 - val_loss: 0.0050 - val_mean_absolute_percentage_error: 261147264.0000\n",
            "Epoch 55/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0125 - mean_absolute_percentage_error: 343682560.0000\n",
            "Epoch 00055: val_loss did not improve from 0.00071\n",
            "9/9 [==============================] - 1s 98ms/step - loss: 0.0125 - mean_absolute_percentage_error: 343682560.0000 - val_loss: 0.0069 - val_mean_absolute_percentage_error: 266754688.0000\n",
            "Epoch 56/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0120 - mean_absolute_percentage_error: 325991808.0000\n",
            "Epoch 00056: val_loss did not improve from 0.00071\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0120 - mean_absolute_percentage_error: 325991808.0000 - val_loss: 0.0016 - val_mean_absolute_percentage_error: 288045856.0000\n",
            "Epoch 57/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0124 - mean_absolute_percentage_error: 335655200.0000\n",
            "Epoch 00057: val_loss did not improve from 0.00071\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0124 - mean_absolute_percentage_error: 335655200.0000 - val_loss: 0.0010 - val_mean_absolute_percentage_error: 284820320.0000\n",
            "Epoch 58/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0126 - mean_absolute_percentage_error: 338727200.0000\n",
            "Epoch 00058: val_loss did not improve from 0.00071\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0126 - mean_absolute_percentage_error: 338727200.0000 - val_loss: 0.0013 - val_mean_absolute_percentage_error: 283207744.0000\n",
            "Epoch 59/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0140 - mean_absolute_percentage_error: 314720512.0000\n",
            "Epoch 00059: val_loss did not improve from 0.00071\n",
            "9/9 [==============================] - 1s 98ms/step - loss: 0.0140 - mean_absolute_percentage_error: 314720512.0000 - val_loss: 0.0031 - val_mean_absolute_percentage_error: 246505792.0000\n",
            "Epoch 60/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0127 - mean_absolute_percentage_error: 305688032.0000\n",
            "Epoch 00060: val_loss did not improve from 0.00071\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0127 - mean_absolute_percentage_error: 305688032.0000 - val_loss: 0.0027 - val_mean_absolute_percentage_error: 292614048.0000\n",
            "Epoch 61/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0123 - mean_absolute_percentage_error: 293727392.0000\n",
            "Epoch 00061: val_loss did not improve from 0.00071\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0123 - mean_absolute_percentage_error: 293727392.0000 - val_loss: 0.0025 - val_mean_absolute_percentage_error: 299337344.0000\n",
            "Epoch 62/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0127 - mean_absolute_percentage_error: 332066272.0000\n",
            "Epoch 00062: val_loss did not improve from 0.00071\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0127 - mean_absolute_percentage_error: 332066272.0000 - val_loss: 0.0020 - val_mean_absolute_percentage_error: 277830976.0000\n",
            "Epoch 63/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0123 - mean_absolute_percentage_error: 334686528.0000\n",
            "Epoch 00063: val_loss improved from 0.00071 to 0.00056, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3b.h5\n",
            "9/9 [==============================] - 1s 128ms/step - loss: 0.0123 - mean_absolute_percentage_error: 334686528.0000 - val_loss: 5.6075e-04 - val_mean_absolute_percentage_error: 279356032.0000\n",
            "Epoch 64/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0124 - mean_absolute_percentage_error: 297818048.0000\n",
            "Epoch 00064: val_loss did not improve from 0.00056\n",
            "9/9 [==============================] - 1s 98ms/step - loss: 0.0124 - mean_absolute_percentage_error: 297818048.0000 - val_loss: 0.0022 - val_mean_absolute_percentage_error: 261964096.0000\n",
            "Epoch 65/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0122 - mean_absolute_percentage_error: 310598336.0000\n",
            "Epoch 00065: val_loss improved from 0.00056 to 0.00050, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3b.h5\n",
            "9/9 [==============================] - 1s 127ms/step - loss: 0.0122 - mean_absolute_percentage_error: 310598336.0000 - val_loss: 5.0282e-04 - val_mean_absolute_percentage_error: 279796960.0000\n",
            "Epoch 66/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0119 - mean_absolute_percentage_error: 308964192.0000\n",
            "Epoch 00066: val_loss did not improve from 0.00050\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0119 - mean_absolute_percentage_error: 308964192.0000 - val_loss: 0.0012 - val_mean_absolute_percentage_error: 276429600.0000\n",
            "Epoch 67/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0117 - mean_absolute_percentage_error: 319254656.0000\n",
            "Epoch 00067: val_loss did not improve from 0.00050\n",
            "9/9 [==============================] - 1s 98ms/step - loss: 0.0117 - mean_absolute_percentage_error: 319254656.0000 - val_loss: 6.0112e-04 - val_mean_absolute_percentage_error: 266548304.0000\n",
            "Epoch 68/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0118 - mean_absolute_percentage_error: 340554432.0000\n",
            "Epoch 00068: val_loss did not improve from 0.00050\n",
            "9/9 [==============================] - 1s 98ms/step - loss: 0.0118 - mean_absolute_percentage_error: 340554432.0000 - val_loss: 0.0016 - val_mean_absolute_percentage_error: 264965904.0000\n",
            "Epoch 69/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0127 - mean_absolute_percentage_error: 337422496.0000\n",
            "Epoch 00069: val_loss did not improve from 0.00050\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0127 - mean_absolute_percentage_error: 337422496.0000 - val_loss: 0.0030 - val_mean_absolute_percentage_error: 289096864.0000\n",
            "Epoch 70/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0119 - mean_absolute_percentage_error: 342329760.0000\n",
            "Epoch 00070: val_loss did not improve from 0.00050\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0119 - mean_absolute_percentage_error: 342329760.0000 - val_loss: 0.0023 - val_mean_absolute_percentage_error: 322763296.0000\n",
            "Epoch 71/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0125 - mean_absolute_percentage_error: 363743968.0000\n",
            "Epoch 00071: val_loss did not improve from 0.00050\n",
            "9/9 [==============================] - 1s 98ms/step - loss: 0.0125 - mean_absolute_percentage_error: 363743968.0000 - val_loss: 0.0024 - val_mean_absolute_percentage_error: 322272480.0000\n",
            "Epoch 72/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0120 - mean_absolute_percentage_error: 305151232.0000\n",
            "Epoch 00072: val_loss did not improve from 0.00050\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0120 - mean_absolute_percentage_error: 305151232.0000 - val_loss: 0.0026 - val_mean_absolute_percentage_error: 282301376.0000\n",
            "Epoch 73/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0115 - mean_absolute_percentage_error: 324343296.0000\n",
            "Epoch 00073: val_loss did not improve from 0.00050\n",
            "9/9 [==============================] - 1s 99ms/step - loss: 0.0115 - mean_absolute_percentage_error: 324343296.0000 - val_loss: 0.0014 - val_mean_absolute_percentage_error: 298038208.0000\n",
            "Epoch 74/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0121 - mean_absolute_percentage_error: 335862464.0000\n",
            "Epoch 00074: val_loss did not improve from 0.00050\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0121 - mean_absolute_percentage_error: 335862464.0000 - val_loss: 0.0010 - val_mean_absolute_percentage_error: 282171936.0000\n",
            "Epoch 75/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0115 - mean_absolute_percentage_error: 311053344.0000\n",
            "Epoch 00075: val_loss did not improve from 0.00050\n",
            "9/9 [==============================] - 1s 98ms/step - loss: 0.0115 - mean_absolute_percentage_error: 311053344.0000 - val_loss: 0.0025 - val_mean_absolute_percentage_error: 257832704.0000\n",
            "Epoch 76/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0112 - mean_absolute_percentage_error: 332484384.0000\n",
            "Epoch 00076: val_loss did not improve from 0.00050\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0112 - mean_absolute_percentage_error: 332484384.0000 - val_loss: 0.0071 - val_mean_absolute_percentage_error: 232810848.0000\n",
            "Epoch 77/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0112 - mean_absolute_percentage_error: 319639424.0000\n",
            "Epoch 00077: val_loss did not improve from 0.00050\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0112 - mean_absolute_percentage_error: 319639424.0000 - val_loss: 0.0018 - val_mean_absolute_percentage_error: 262335456.0000\n",
            "Epoch 78/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0114 - mean_absolute_percentage_error: 307922624.0000\n",
            "Epoch 00078: val_loss did not improve from 0.00050\n",
            "9/9 [==============================] - 1s 98ms/step - loss: 0.0114 - mean_absolute_percentage_error: 307922624.0000 - val_loss: 0.0027 - val_mean_absolute_percentage_error: 249293792.0000\n",
            "Epoch 79/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0111 - mean_absolute_percentage_error: 304980000.0000\n",
            "Epoch 00079: val_loss did not improve from 0.00050\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0111 - mean_absolute_percentage_error: 304980000.0000 - val_loss: 0.0052 - val_mean_absolute_percentage_error: 235196192.0000\n",
            "Epoch 80/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0113 - mean_absolute_percentage_error: 291225088.0000\n",
            "Epoch 00080: val_loss did not improve from 0.00050\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0113 - mean_absolute_percentage_error: 291225088.0000 - val_loss: 0.0011 - val_mean_absolute_percentage_error: 264808528.0000\n",
            "Epoch 81/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0113 - mean_absolute_percentage_error: 293612896.0000\n",
            "Epoch 00081: val_loss did not improve from 0.00050\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0113 - mean_absolute_percentage_error: 293612896.0000 - val_loss: 0.0011 - val_mean_absolute_percentage_error: 267136080.0000\n",
            "Epoch 82/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0113 - mean_absolute_percentage_error: 293294080.0000\n",
            "Epoch 00082: val_loss did not improve from 0.00050\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0113 - mean_absolute_percentage_error: 293294080.0000 - val_loss: 0.0030 - val_mean_absolute_percentage_error: 281801056.0000\n",
            "Epoch 83/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0114 - mean_absolute_percentage_error: 293614848.0000\n",
            "Epoch 00083: val_loss did not improve from 0.00050\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0114 - mean_absolute_percentage_error: 293614848.0000 - val_loss: 0.0012 - val_mean_absolute_percentage_error: 293448768.0000\n",
            "Epoch 84/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0110 - mean_absolute_percentage_error: 303851232.0000\n",
            "Epoch 00084: val_loss did not improve from 0.00050\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0110 - mean_absolute_percentage_error: 303851232.0000 - val_loss: 0.0018 - val_mean_absolute_percentage_error: 258328864.0000\n",
            "Epoch 85/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0113 - mean_absolute_percentage_error: 306385376.0000\n",
            "Epoch 00085: val_loss did not improve from 0.00050\n",
            "9/9 [==============================] - 1s 98ms/step - loss: 0.0113 - mean_absolute_percentage_error: 306385376.0000 - val_loss: 0.0044 - val_mean_absolute_percentage_error: 246656032.0000\n",
            "Epoch 86/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0113 - mean_absolute_percentage_error: 311921856.0000\n",
            "Epoch 00086: val_loss did not improve from 0.00050\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0113 - mean_absolute_percentage_error: 311921856.0000 - val_loss: 0.0041 - val_mean_absolute_percentage_error: 236765152.0000\n",
            "Epoch 87/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0110 - mean_absolute_percentage_error: 302591360.0000\n",
            "Epoch 00087: val_loss did not improve from 0.00050\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0110 - mean_absolute_percentage_error: 302591360.0000 - val_loss: 0.0108 - val_mean_absolute_percentage_error: 209400240.0000\n",
            "Epoch 88/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0111 - mean_absolute_percentage_error: 305855840.0000\n",
            "Epoch 00088: val_loss did not improve from 0.00050\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0111 - mean_absolute_percentage_error: 305855840.0000 - val_loss: 0.0251 - val_mean_absolute_percentage_error: 168653904.0000\n",
            "Epoch 89/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0114 - mean_absolute_percentage_error: 270215680.0000\n",
            "Epoch 00089: val_loss did not improve from 0.00050\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0114 - mean_absolute_percentage_error: 270215680.0000 - val_loss: 0.0153 - val_mean_absolute_percentage_error: 190021088.0000\n",
            "Epoch 90/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0104 - mean_absolute_percentage_error: 278316512.0000\n",
            "Epoch 00090: val_loss did not improve from 0.00050\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0104 - mean_absolute_percentage_error: 278316512.0000 - val_loss: 0.0128 - val_mean_absolute_percentage_error: 188210448.0000\n",
            "Epoch 00090: early stopping\n"
          ]
        }
      ],
      "execution_count": 101,
      "metadata": {
        "id": "S3GLE6qSUHbT",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "4e74d565-87d1-4b02-dcb2-c72cd8ca2343"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "hist1_df =pd.DataFrame(hist1.history)\n",
        "hist1_df[['loss', 'val_loss']].plot()"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 102,
          "data": {
            "text/plain": [
              "<matplotlib.axes._subplots.AxesSubplot at 0x7f27ee4a8be0>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": [
              "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\n"
            ],
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ],
      "execution_count": 102,
      "metadata": {
        "id": "hvpsZL3hUHZk",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 282
        },
        "outputId": "f90d9a0e-131e-438a-e13c-f50f916568b4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "hist1_df[['val_loss']].min(), np.argmin(hist1_df[['val_loss']])"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 103,
          "data": {
            "text/plain": [
              "(val_loss    0.000503\n",
              " dtype: float64, 64)"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ],
      "execution_count": 103,
      "metadata": {
        "id": "_iFOZtYlUxCS",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "b6717ac4-3812-4576-eee1-7a1651f4ec76"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Model #3: Train for V "
      ],
      "metadata": {
        "id": "GEBHOFU6VBRp",
        "colab_type": "text"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "train_target = 2\n",
        "\n",
        "# compile model\n",
        "# BATCH_SIZE = 256\n",
        "# EPOCHS = 200\n",
        "# LR = 0.001\n",
        "\n",
        "model2 = build_cnn_model()\n",
        "\n",
        "optimizer = tf.keras.optimizers.Adam()\n",
        "optimizer = tfa.optimizers.SWA(optimizer)\n",
        "\n",
        "# global weight2\n",
        "if train_target == 1: \n",
        "    # only for M\n",
        "    weight2 = np.array([0,0,1,0])\n",
        "else: \n",
        "    # only for V\n",
        "    weight2 = np.array([0,0,0,1])\n",
        "    \n",
        "\n",
        "model2.compile(loss=my_loss_E2, optimizer=optimizer, )   # metrics=[r2_keras]\n",
        "\n",
        "\n",
        "# callbacks\n",
        "MODEL_PATH = '/content/drive/My Drive/ML Projects/DACON/Colision/'\n",
        "MODEL_NAME = 'CNN_model_3c.h5'      # _epoch{epoch:02d}_loss{val_loss:.2f}\n",
        "\n",
        "es = tf.keras.callbacks.EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=25)\n",
        "mc = tf.keras.callbacks.ModelCheckpoint(MODEL_PATH+MODEL_NAME, monitor='val_loss', save_best_only=True, save_weights_only=False, verbose=1)\n",
        "\n",
        "# select LR schedule Callback\n",
        "# rlr = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', patience=10, verbose=1, factor=0.7)\n",
        "# lr_schedule = step_decay_schedule(initial_lr=1e-2, decay_factor=0.5, step_size=5)\n",
        "lr_cyclic = CyclicLR(base_lr=0.001, max_lr=0.006, step_size=25., mode='exp_range', gamma=0.99994)\n",
        "# lr_cos = WarmUpCosineDecayScheduler()\n",
        "\n",
        "callbacks=[es, mc, lr_cyclic]             \n",
        "# ,rlr , lr_cos, lr_cyclic"
      ],
      "outputs": [],
      "execution_count": 104,
      "metadata": {
        "id": "BZ2gOs4PXnz6",
        "colab_type": "code",
        "colab": {}
      }
    },
    {
      "cell_type": "code",
      "source": [
        "hist2 = model2.fit(X, y,               \n",
        "                 validation_split=0.2,     \n",
        "                 batch_size=BATCH_SIZE,\n",
        "                 epochs=EPOCHS,\n",
        "                 verbose=1,\n",
        "                 shuffle=True,\n",
        "                 callbacks=callbacks)"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0871\n",
            "Epoch 00001: val_loss improved from inf to 3.46859, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3c.h5\n",
            "9/9 [==============================] - 1s 154ms/step - loss: 0.0871 - val_loss: 3.4686\n",
            "Epoch 2/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0187\n",
            "Epoch 00002: val_loss improved from 3.46859 to 0.97438, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3c.h5\n",
            "9/9 [==============================] - 1s 127ms/step - loss: 0.0187 - val_loss: 0.9744\n",
            "Epoch 3/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0099\n",
            "Epoch 00003: val_loss did not improve from 0.97438\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0099 - val_loss: 4.2096\n",
            "Epoch 4/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0075\n",
            "Epoch 00004: val_loss did not improve from 0.97438\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0075 - val_loss: 5.6002\n",
            "Epoch 5/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0060\n",
            "Epoch 00005: val_loss did not improve from 0.97438\n",
            "9/9 [==============================] - 1s 98ms/step - loss: 0.0060 - val_loss: 1.9877\n",
            "Epoch 6/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0059\n",
            "Epoch 00006: val_loss improved from 0.97438 to 0.96264, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3c.h5\n",
            "9/9 [==============================] - 1s 128ms/step - loss: 0.0059 - val_loss: 0.9626\n",
            "Epoch 7/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0062\n",
            "Epoch 00007: val_loss improved from 0.96264 to 0.56249, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3c.h5\n",
            "9/9 [==============================] - 1s 125ms/step - loss: 0.0062 - val_loss: 0.5625\n",
            "Epoch 8/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0071\n",
            "Epoch 00008: val_loss improved from 0.56249 to 0.24590, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3c.h5\n",
            "9/9 [==============================] - 1s 124ms/step - loss: 0.0071 - val_loss: 0.2459\n",
            "Epoch 9/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0068\n",
            "Epoch 00009: val_loss did not improve from 0.24590\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0068 - val_loss: 0.2954\n",
            "Epoch 10/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0051\n",
            "Epoch 00010: val_loss improved from 0.24590 to 0.13505, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3c.h5\n",
            "9/9 [==============================] - 1s 126ms/step - loss: 0.0051 - val_loss: 0.1351\n",
            "Epoch 11/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0048\n",
            "Epoch 00011: val_loss improved from 0.13505 to 0.09280, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3c.h5\n",
            "9/9 [==============================] - 1s 127ms/step - loss: 0.0048 - val_loss: 0.0928\n",
            "Epoch 12/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0051\n",
            "Epoch 00012: val_loss improved from 0.09280 to 0.06391, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3c.h5\n",
            "9/9 [==============================] - 1s 126ms/step - loss: 0.0051 - val_loss: 0.0639\n",
            "Epoch 13/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0047\n",
            "Epoch 00013: val_loss improved from 0.06391 to 0.05686, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3c.h5\n",
            "9/9 [==============================] - 1s 123ms/step - loss: 0.0047 - val_loss: 0.0569\n",
            "Epoch 14/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0050\n",
            "Epoch 00014: val_loss improved from 0.05686 to 0.03770, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3c.h5\n",
            "9/9 [==============================] - 1s 128ms/step - loss: 0.0050 - val_loss: 0.0377\n",
            "Epoch 15/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0053\n",
            "Epoch 00015: val_loss improved from 0.03770 to 0.00994, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3c.h5\n",
            "9/9 [==============================] - 1s 127ms/step - loss: 0.0053 - val_loss: 0.0099\n",
            "Epoch 16/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0048\n",
            "Epoch 00016: val_loss did not improve from 0.00994\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0048 - val_loss: 0.0182\n",
            "Epoch 17/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0043\n",
            "Epoch 00017: val_loss did not improve from 0.00994\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0043 - val_loss: 0.0158\n",
            "Epoch 18/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0041\n",
            "Epoch 00018: val_loss improved from 0.00994 to 0.00905, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3c.h5\n",
            "9/9 [==============================] - 1s 127ms/step - loss: 0.0041 - val_loss: 0.0090\n",
            "Epoch 19/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0042\n",
            "Epoch 00019: val_loss improved from 0.00905 to 0.00793, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3c.h5\n",
            "9/9 [==============================] - 1s 127ms/step - loss: 0.0042 - val_loss: 0.0079\n",
            "Epoch 20/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0046\n",
            "Epoch 00020: val_loss improved from 0.00793 to 0.00472, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3c.h5\n",
            "9/9 [==============================] - 1s 124ms/step - loss: 0.0046 - val_loss: 0.0047\n",
            "Epoch 21/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0046\n",
            "Epoch 00021: val_loss improved from 0.00472 to 0.00181, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3c.h5\n",
            "9/9 [==============================] - 1s 124ms/step - loss: 0.0046 - val_loss: 0.0018\n",
            "Epoch 22/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0039\n",
            "Epoch 00022: val_loss did not improve from 0.00181\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.0039 - val_loss: 0.0033\n",
            "Epoch 23/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0037\n",
            "Epoch 00023: val_loss did not improve from 0.00181\n",
            "9/9 [==============================] - 1s 98ms/step - loss: 0.0037 - val_loss: 0.0024\n",
            "Epoch 24/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0039\n",
            "Epoch 00024: val_loss improved from 0.00181 to 0.00057, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3c.h5\n",
            "9/9 [==============================] - 1s 126ms/step - loss: 0.0039 - val_loss: 5.6524e-04\n",
            "Epoch 25/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0040\n",
            "Epoch 00025: val_loss did not improve from 0.00057\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0040 - val_loss: 8.8938e-04\n",
            "Epoch 26/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0042\n",
            "Epoch 00026: val_loss did not improve from 0.00057\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0042 - val_loss: 0.0019\n",
            "Epoch 27/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0036\n",
            "Epoch 00027: val_loss did not improve from 0.00057\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0036 - val_loss: 0.0041\n",
            "Epoch 28/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0034\n",
            "Epoch 00028: val_loss did not improve from 0.00057\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0034 - val_loss: 0.0015\n",
            "Epoch 29/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0033\n",
            "Epoch 00029: val_loss improved from 0.00057 to 0.00034, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3c.h5\n",
            "9/9 [==============================] - 1s 127ms/step - loss: 0.0033 - val_loss: 3.3894e-04\n",
            "Epoch 30/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0030\n",
            "Epoch 00030: val_loss did not improve from 0.00034\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0030 - val_loss: 0.0016\n",
            "Epoch 31/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0035\n",
            "Epoch 00031: val_loss did not improve from 0.00034\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.0035 - val_loss: 7.8633e-04\n",
            "Epoch 32/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0032\n",
            "Epoch 00032: val_loss did not improve from 0.00034\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0032 - val_loss: 0.0014\n",
            "Epoch 33/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0029\n",
            "Epoch 00033: val_loss did not improve from 0.00034\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.0029 - val_loss: 0.0016\n",
            "Epoch 34/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0031\n",
            "Epoch 00034: val_loss did not improve from 0.00034\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0031 - val_loss: 3.6094e-04\n",
            "Epoch 35/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0031\n",
            "Epoch 00035: val_loss did not improve from 0.00034\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0031 - val_loss: 0.0013\n",
            "Epoch 36/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0034\n",
            "Epoch 00036: val_loss did not improve from 0.00034\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0034 - val_loss: 5.6395e-04\n",
            "Epoch 37/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0034\n",
            "Epoch 00037: val_loss improved from 0.00034 to 0.00029, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3c.h5\n",
            "9/9 [==============================] - 1s 126ms/step - loss: 0.0034 - val_loss: 2.9415e-04\n",
            "Epoch 38/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0032\n",
            "Epoch 00038: val_loss did not improve from 0.00029\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0032 - val_loss: 4.2179e-04\n",
            "Epoch 39/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0028\n",
            "Epoch 00039: val_loss improved from 0.00029 to 0.00028, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3c.h5\n",
            "9/9 [==============================] - 1s 129ms/step - loss: 0.0028 - val_loss: 2.7842e-04\n",
            "Epoch 40/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0028\n",
            "Epoch 00040: val_loss did not improve from 0.00028\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0028 - val_loss: 7.4145e-04\n",
            "Epoch 41/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0029\n",
            "Epoch 00041: val_loss did not improve from 0.00028\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0029 - val_loss: 9.9664e-04\n",
            "Epoch 42/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0031\n",
            "Epoch 00042: val_loss did not improve from 0.00028\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0031 - val_loss: 3.3143e-04\n",
            "Epoch 43/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0032\n",
            "Epoch 00043: val_loss did not improve from 0.00028\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0032 - val_loss: 0.0021\n",
            "Epoch 44/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0029\n",
            "Epoch 00044: val_loss did not improve from 0.00028\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0029 - val_loss: 0.0025\n",
            "Epoch 45/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0027\n",
            "Epoch 00045: val_loss did not improve from 0.00028\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0027 - val_loss: 0.0010\n",
            "Epoch 46/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0027\n",
            "Epoch 00046: val_loss did not improve from 0.00028\n",
            "9/9 [==============================] - 1s 98ms/step - loss: 0.0027 - val_loss: 0.0011\n",
            "Epoch 47/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0029\n",
            "Epoch 00047: val_loss did not improve from 0.00028\n",
            "9/9 [==============================] - 1s 98ms/step - loss: 0.0029 - val_loss: 3.7903e-04\n",
            "Epoch 48/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0030\n",
            "Epoch 00048: val_loss did not improve from 0.00028\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0030 - val_loss: 0.0018\n",
            "Epoch 49/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0025\n",
            "Epoch 00049: val_loss did not improve from 0.00028\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.0025 - val_loss: 0.0011\n",
            "Epoch 50/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0025\n",
            "Epoch 00050: val_loss improved from 0.00028 to 0.00026, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3c.h5\n",
            "9/9 [==============================] - 2s 263ms/step - loss: 0.0025 - val_loss: 2.6267e-04\n",
            "Epoch 51/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0021\n",
            "Epoch 00051: val_loss improved from 0.00026 to 0.00010, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3c.h5\n",
            "9/9 [==============================] - 1s 123ms/step - loss: 0.0021 - val_loss: 9.6081e-05\n",
            "Epoch 52/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0025\n",
            "Epoch 00052: val_loss did not improve from 0.00010\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.0025 - val_loss: 4.0457e-04\n",
            "Epoch 53/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0022\n",
            "Epoch 00053: val_loss did not improve from 0.00010\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0022 - val_loss: 2.6331e-04\n",
            "Epoch 54/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0025\n",
            "Epoch 00054: val_loss did not improve from 0.00010\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0025 - val_loss: 3.6104e-04\n",
            "Epoch 55/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0026\n",
            "Epoch 00055: val_loss did not improve from 0.00010\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0026 - val_loss: 0.0013\n",
            "Epoch 56/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0024\n",
            "Epoch 00056: val_loss did not improve from 0.00010\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0024 - val_loss: 1.1702e-04\n",
            "Epoch 57/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0021\n",
            "Epoch 00057: val_loss did not improve from 0.00010\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0021 - val_loss: 3.7418e-04\n",
            "Epoch 58/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0021\n",
            "Epoch 00058: val_loss did not improve from 0.00010\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0021 - val_loss: 7.2435e-04\n",
            "Epoch 59/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0025\n",
            "Epoch 00059: val_loss did not improve from 0.00010\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.0025 - val_loss: 0.0023\n",
            "Epoch 60/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0028\n",
            "Epoch 00060: val_loss did not improve from 0.00010\n",
            "9/9 [==============================] - 1s 101ms/step - loss: 0.0028 - val_loss: 1.8343e-04\n",
            "Epoch 61/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0025\n",
            "Epoch 00061: val_loss did not improve from 0.00010\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0025 - val_loss: 1.8223e-04\n",
            "Epoch 62/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0021\n",
            "Epoch 00062: val_loss did not improve from 0.00010\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0021 - val_loss: 1.6884e-04\n",
            "Epoch 63/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0021\n",
            "Epoch 00063: val_loss did not improve from 0.00010\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0021 - val_loss: 2.0246e-04\n",
            "Epoch 64/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0022\n",
            "Epoch 00064: val_loss did not improve from 0.00010\n",
            "9/9 [==============================] - 1s 98ms/step - loss: 0.0022 - val_loss: 0.0023\n",
            "Epoch 65/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0021\n",
            "Epoch 00065: val_loss did not improve from 0.00010\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.0021 - val_loss: 1.4645e-04\n",
            "Epoch 66/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0020\n",
            "Epoch 00066: val_loss did not improve from 0.00010\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0020 - val_loss: 2.0786e-04\n",
            "Epoch 67/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0018\n",
            "Epoch 00067: val_loss did not improve from 0.00010\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.0018 - val_loss: 4.4842e-04\n",
            "Epoch 68/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0019\n",
            "Epoch 00068: val_loss did not improve from 0.00010\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.0019 - val_loss: 1.8801e-04\n",
            "Epoch 69/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0020\n",
            "Epoch 00069: val_loss did not improve from 0.00010\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.0020 - val_loss: 3.0014e-04\n",
            "Epoch 70/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0019\n",
            "Epoch 00070: val_loss did not improve from 0.00010\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0019 - val_loss: 1.6696e-04\n",
            "Epoch 71/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0021\n",
            "Epoch 00071: val_loss did not improve from 0.00010\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0021 - val_loss: 0.0021\n",
            "Epoch 72/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0025\n",
            "Epoch 00072: val_loss did not improve from 0.00010\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0025 - val_loss: 0.0016\n",
            "Epoch 73/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0021\n",
            "Epoch 00073: val_loss improved from 0.00010 to 0.00006, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3c.h5\n",
            "9/9 [==============================] - 2s 264ms/step - loss: 0.0021 - val_loss: 6.4161e-05\n",
            "Epoch 74/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0019\n",
            "Epoch 00074: val_loss did not improve from 0.00006\n",
            "9/9 [==============================] - 1s 94ms/step - loss: 0.0019 - val_loss: 1.9836e-04\n",
            "Epoch 75/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0021\n",
            "Epoch 00075: val_loss did not improve from 0.00006\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0021 - val_loss: 2.9642e-04\n",
            "Epoch 76/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0025\n",
            "Epoch 00076: val_loss did not improve from 0.00006\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.0025 - val_loss: 4.4424e-04\n",
            "Epoch 77/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0020\n",
            "Epoch 00077: val_loss did not improve from 0.00006\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0020 - val_loss: 1.6074e-04\n",
            "Epoch 78/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0019\n",
            "Epoch 00078: val_loss improved from 0.00006 to 0.00005, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3c.h5\n",
            "9/9 [==============================] - 1s 125ms/step - loss: 0.0019 - val_loss: 4.8348e-05\n",
            "Epoch 79/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0018\n",
            "Epoch 00079: val_loss did not improve from 0.00005\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0018 - val_loss: 6.3505e-04\n",
            "Epoch 80/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0017\n",
            "Epoch 00080: val_loss did not improve from 0.00005\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.0017 - val_loss: 1.3706e-04\n",
            "Epoch 81/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0018\n",
            "Epoch 00081: val_loss did not improve from 0.00005\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.0018 - val_loss: 8.5688e-05\n",
            "Epoch 82/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0018\n",
            "Epoch 00082: val_loss did not improve from 0.00005\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0018 - val_loss: 2.3681e-04\n",
            "Epoch 83/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0018\n",
            "Epoch 00083: val_loss did not improve from 0.00005\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0018 - val_loss: 1.1907e-04\n",
            "Epoch 84/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0017\n",
            "Epoch 00084: val_loss did not improve from 0.00005\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0017 - val_loss: 9.0928e-05\n",
            "Epoch 85/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0018\n",
            "Epoch 00085: val_loss did not improve from 0.00005\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0018 - val_loss: 7.3646e-05\n",
            "Epoch 86/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0017\n",
            "Epoch 00086: val_loss did not improve from 0.00005\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0017 - val_loss: 1.2202e-04\n",
            "Epoch 87/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0018\n",
            "Epoch 00087: val_loss did not improve from 0.00005\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.0018 - val_loss: 3.2718e-04\n",
            "Epoch 88/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0020\n",
            "Epoch 00088: val_loss did not improve from 0.00005\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0020 - val_loss: 3.2838e-04\n",
            "Epoch 89/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0017\n",
            "Epoch 00089: val_loss improved from 0.00005 to 0.00003, saving model to /content/drive/My Drive/ML Projects/DACON/Colision/CNN_model_3c.h5\n",
            "9/9 [==============================] - 1s 127ms/step - loss: 0.0017 - val_loss: 3.2878e-05\n",
            "Epoch 90/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0017\n",
            "Epoch 00090: val_loss did not improve from 0.00003\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0017 - val_loss: 5.0270e-05\n",
            "Epoch 91/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0018\n",
            "Epoch 00091: val_loss did not improve from 0.00003\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0018 - val_loss: 1.0408e-04\n",
            "Epoch 92/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0019\n",
            "Epoch 00092: val_loss did not improve from 0.00003\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0019 - val_loss: 6.8265e-04\n",
            "Epoch 93/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0020\n",
            "Epoch 00093: val_loss did not improve from 0.00003\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0020 - val_loss: 2.3623e-04\n",
            "Epoch 94/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0019\n",
            "Epoch 00094: val_loss did not improve from 0.00003\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0019 - val_loss: 3.1925e-04\n",
            "Epoch 95/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0019\n",
            "Epoch 00095: val_loss did not improve from 0.00003\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.0019 - val_loss: 1.7677e-04\n",
            "Epoch 96/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0018\n",
            "Epoch 00096: val_loss did not improve from 0.00003\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0018 - val_loss: 1.5754e-04\n",
            "Epoch 97/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0016\n",
            "Epoch 00097: val_loss did not improve from 0.00003\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0016 - val_loss: 1.3614e-04\n",
            "Epoch 98/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0022\n",
            "Epoch 00098: val_loss did not improve from 0.00003\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0022 - val_loss: 1.5055e-04\n",
            "Epoch 99/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0023\n",
            "Epoch 00099: val_loss did not improve from 0.00003\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0023 - val_loss: 7.8320e-05\n",
            "Epoch 100/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0018\n",
            "Epoch 00100: val_loss did not improve from 0.00003\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0018 - val_loss: 6.2444e-05\n",
            "Epoch 101/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0017\n",
            "Epoch 00101: val_loss did not improve from 0.00003\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0017 - val_loss: 2.3711e-04\n",
            "Epoch 102/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0017\n",
            "Epoch 00102: val_loss did not improve from 0.00003\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0017 - val_loss: 2.1954e-04\n",
            "Epoch 103/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0018\n",
            "Epoch 00103: val_loss did not improve from 0.00003\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0018 - val_loss: 2.4459e-04\n",
            "Epoch 104/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0023\n",
            "Epoch 00104: val_loss did not improve from 0.00003\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.0023 - val_loss: 1.4342e-04\n",
            "Epoch 105/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0019\n",
            "Epoch 00105: val_loss did not improve from 0.00003\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0019 - val_loss: 2.2038e-04\n",
            "Epoch 106/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0016\n",
            "Epoch 00106: val_loss did not improve from 0.00003\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0016 - val_loss: 1.0985e-04\n",
            "Epoch 107/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0016\n",
            "Epoch 00107: val_loss did not improve from 0.00003\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0016 - val_loss: 8.7238e-05\n",
            "Epoch 108/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0016\n",
            "Epoch 00108: val_loss did not improve from 0.00003\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0016 - val_loss: 1.5564e-04\n",
            "Epoch 109/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0020\n",
            "Epoch 00109: val_loss did not improve from 0.00003\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0020 - val_loss: 3.1088e-04\n",
            "Epoch 110/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0019\n",
            "Epoch 00110: val_loss did not improve from 0.00003\n",
            "9/9 [==============================] - 1s 98ms/step - loss: 0.0019 - val_loss: 4.4180e-04\n",
            "Epoch 111/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0020\n",
            "Epoch 00111: val_loss did not improve from 0.00003\n",
            "9/9 [==============================] - 1s 99ms/step - loss: 0.0020 - val_loss: 2.2765e-04\n",
            "Epoch 112/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0018\n",
            "Epoch 00112: val_loss did not improve from 0.00003\n",
            "9/9 [==============================] - 1s 95ms/step - loss: 0.0018 - val_loss: 3.0583e-04\n",
            "Epoch 113/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0018\n",
            "Epoch 00113: val_loss did not improve from 0.00003\n",
            "9/9 [==============================] - 1s 97ms/step - loss: 0.0018 - val_loss: 1.6106e-04\n",
            "Epoch 114/200\n",
            "9/9 [==============================] - ETA: 0s - loss: 0.0018\n",
            "Epoch 00114: val_loss did not improve from 0.00003\n",
            "9/9 [==============================] - 1s 96ms/step - loss: 0.0018 - val_loss: 5.5225e-04\n",
            "Epoch 00114: early stopping\n"
          ]
        }
      ],
      "execution_count": 105,
      "metadata": {
        "id": "ZlB9oJXIXn5d",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "8f18abe3-1d29-40c8-e339-a7978f45ea8f"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "hist2_df =pd.DataFrame(hist2.history)\n",
        "hist2_df[['loss', 'val_loss']].plot()"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 106,
          "data": {
            "text/plain": [
              "<matplotlib.axes._subplots.AxesSubplot at 0x7f27e55a2be0>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": [
              "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\n"
            ],
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ],
      "execution_count": 106,
      "metadata": {
        "id": "u16Ga0xAXn3O",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 282
        },
        "outputId": "b327aada-e9fd-4a62-a0a0-6cf1fa169cee"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "hist2_df[['val_loss']].min(), np.argmin(hist2_df[['val_loss']])"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 107,
          "data": {
            "text/plain": [
              "(val_loss    0.000033\n",
              " dtype: float64, 88)"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ],
      "execution_count": 107,
      "metadata": {
        "id": "jWPcGAzmX8j4",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "cb635bc7-b9ee-47f3-bce7-56d7d7c2e2ca"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Predict Test set"
      ],
      "metadata": {
        "id": "tm_6VMKMYfEV",
        "colab_type": "text"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model0_cp = tf.keras.models.load_model(MODEL_PATH+'CNN_model_3a.h5', custom_objects={'my_loss_E1': my_loss, 'r2_keras':r2_keras})\n",
        "model1_cp = tf.keras.models.load_model(MODEL_PATH+'CNN_model_3b.h5', custom_objects={'my_loss_E2': my_loss})\n",
        "model2_cp = tf.keras.models.load_model(MODEL_PATH+'CNN_model_3c.h5', custom_objects={'my_loss_E2': my_loss})"
      ],
      "outputs": [],
      "execution_count": 108,
      "metadata": {
        "id": "iXupoeGGXnx4",
        "colab_type": "code",
        "colab": {}
      }
    },
    {
      "cell_type": "code",
      "source": [
        "subm.head()"
      ],
      "outputs": [],
      "execution_count": null,
      "metadata": {
        "id": "vF-XLP_-Zff7",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 195
        },
        "outputId": "96680588-cf5e-4302-dbb2-6880dfc80dc9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Target 0\n",
        "test_preds = model0_cp.predict(X_test)\n",
        "subm.iloc[:,1] = test_preds[:,0]\n",
        "subm.iloc[:,2] = test_preds[:,1]\n",
        "\n",
        "# Target 1\n",
        "test_preds = model1_cp.predict(X_test)\n",
        "subm.iloc[:,3] = test_preds[:,2]\n",
        "\n",
        "# Target 2\n",
        "test_preds = model2_cp.predict(X_test)\n",
        "subm.iloc[:,4] = test_preds[:,3]"
      ],
      "outputs": [],
      "execution_count": 110,
      "metadata": {
        "id": "IKnc70XwYiKQ",
        "colab_type": "code",
        "colab": {}
      }
    },
    {
      "cell_type": "code",
      "source": [
        "subm.iloc[:, 1:].hist();"
      ],
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": [
              "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\n"
            ],
            "text/plain": [
              "<Figure size 432x288 with 4 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ],
      "execution_count": 111,
      "metadata": {
        "id": "ldaHGk2JYiFs",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 281
        },
        "outputId": "e600f101-46ce-4a7b-c312-84ad6be2f755"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Submission"
      ],
      "metadata": {
        "id": "Q8dXFHVjakBl",
        "colab_type": "text"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "subm.to_csv('submission_cnn3.csv', index=False)"
      ],
      "outputs": [],
      "execution_count": 113,
      "metadata": {
        "id": "SpN8XpUFX43f",
        "colab_type": "code",
        "colab": {}
      }
    },
    {
      "cell_type": "code",
      "source": [
        "subm.head()"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 114,
          "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>id</th>\n",
              "      <th>X</th>\n",
              "      <th>Y</th>\n",
              "      <th>M</th>\n",
              "      <th>V</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>2800</td>\n",
              "      <td>-250.971191</td>\n",
              "      <td>-29.678473</td>\n",
              "      <td>109.553986</td>\n",
              "      <td>0.409991</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>2801</td>\n",
              "      <td>304.797089</td>\n",
              "      <td>-280.788208</td>\n",
              "      <td>89.494713</td>\n",
              "      <td>0.405074</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>2802</td>\n",
              "      <td>-245.229309</td>\n",
              "      <td>132.538406</td>\n",
              "      <td>32.327354</td>\n",
              "      <td>0.377066</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>2803</td>\n",
              "      <td>153.611145</td>\n",
              "      <td>261.543152</td>\n",
              "      <td>28.577295</td>\n",
              "      <td>0.385241</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>2804</td>\n",
              "      <td>-141.282501</td>\n",
              "      <td>185.007446</td>\n",
              "      <td>132.431122</td>\n",
              "      <td>0.408162</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "     id           X           Y           M         V\n",
              "0  2800 -250.971191  -29.678473  109.553986  0.409991\n",
              "1  2801  304.797089 -280.788208   89.494713  0.405074\n",
              "2  2802 -245.229309  132.538406   32.327354  0.377066\n",
              "3  2803  153.611145  261.543152   28.577295  0.385241\n",
              "4  2804 -141.282501  185.007446  132.431122  0.408162"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ],
      "execution_count": 114,
      "metadata": {
        "id": "UQuQKyVKX458",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 195
        },
        "outputId": "bd5aa966-0ecb-48bd-dc65-b61aa11db82d"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "`LB = 0.01474`\n",
        "\n",
        "- CNN Model1-a rlr \n",
        "- CNN Model1-b rlr  `val_loss=0.04020`\n",
        "- CNN Model1-c rlr \n",
        "\n",
        "\n",
        "--------------------------------------------------\n",
        "`LB = 0.01103`\n",
        "\n",
        "- CNN Model2-a cyclic lr `val_loss=0.002392`\n",
        "- CNN Model2-b cyclic lr `val_loss=0.00045`\n",
        "- CNN Model2-c cyclic lr `val_loss=0.000064`\n",
        "\n",
        "--------------------------------------------------\n",
        "\n",
        "`LB = 0.00966`  Pos. 5\n",
        "\n",
        "- CNN Model3-a cyclic+SWA+k5 `val_loss=0.0018968`\n",
        "- CNN Model3-b cyclic+SWA+k5 `val_loss=0.0005028`\n",
        "- CNN Model3-c cyclic+SWA+k5 `val_loss=3.3e-05`\n"
      ],
      "metadata": {
        "id": "CL69iIgRdswH",
        "colab_type": "text"
      }
    }
  ],
  "metadata": {
    "colab": {
      "name": "DACON Collision detection CNN.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "3_v__qXGlPXv",
        "RVmH2C2rM5gY",
        "OjJdd9Cbj3fP",
        "oS5pY8HI6r1Q",
        "Qw6miCODagYI"
      ],
      "toc_visible": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU",
    "nteract": {
      "version": "0.23.1"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}