transform_encoder_lstm_TPU_V15.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "language": "python",
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.7.10",
      "mimetype": "text/x-python",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "file_extension": ".py"
    },
    "colab": {
      "name": "transform_encoder_lstm_TPU-V15.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "machine_shape": "hm",
      "include_colab_link": true
    },
    "accelerator": "TPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/bobbercheng/ventilator-pressure-prediction/blob/master/transform_encoder_lstm_TPU_V15.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Yh6Zg50KJQBQ"
      },
      "source": [
        "V1: Keep R/C, improve\n",
        "\n",
        "V2: Add R**2, no improve\n",
        "\n",
        "V3: Update model from https://www.kaggle.com/dlaststark/gb-vpp-pulp-fiction. Not much improve compare V1\n",
        "\n",
        "V4: Use whole db for test Fold-1\n",
        "Fold-1 | OOF Score: 0.15912771348961205\n",
        "\n",
        "Run it again in Kaggle:\n",
        "\n",
        "Fold-1 | OOF Score: 0.1606402072946816\n",
        "\n",
        "V5: Add loading ScaleLayer from saved model\n",
        "\n",
        "V6: Add TransformerEncoder. TransformerEncoder(128, 512, 8, name=\"transformer_layer\")(x). Testing in GPU.\n",
        "\n",
        "V7: Try to scale targe to 0-1, but it slow the train as MASE cannot be scaled.\n",
        "\n",
        "V8: Removed target scale.\n",
        "Epoch 00022: val_loss improved from 0.32912 to 0.30967, saving model to ./model-gpu/Bidirect_LSTM_model_1C.h5\n",
        "Epoch 23/150\n",
        "127/127 [==============================] - 161s 1s/step - loss: 0.3176 - val_loss: 0.2917\n",
        "\n",
        "Not Good as without TransformerEncoder. Change paramemter back to \n",
        "\n",
        "V8: Change attention result to multiple instead of concate.\n",
        "\n",
        "Loss is smaller than without LayerNormalization, but CV is bigger. It means it overfit the train data.\n",
        "\n",
        "TransformerEncoder(128, 512, 8, 0.3, name=\"transformer_layer\")\n",
        "\n",
        "Epoch 00181: val_loss did not improve from 0.16212\n",
        "Epoch 182/200\n",
        "127/127 [==============================] - 163s 1s/step - loss: 0.0448 - val_loss: 0.1655\n",
        "\n",
        "Epoch 00182: ReduceLROnPlateau reducing learning rate to 5.6313510867767036e-05.\n",
        "\n",
        "Epoch 00182: val_loss did not improve from 0.16212\n",
        "Restoring model weights from the end of the best epoch.\n",
        "Epoch 00182: early stopping\n",
        "Fold-1 | OOF Score: 0.16211654680482343\n",
        "\n",
        "V9: Increase attention dropout to 0.6, add 0.01 droupout to input\n",
        "Epoch 00123: ReduceLROnPlateau reducing learning rate to 0.00031640623637940735.\n",
        "\n",
        "Epoch 00123: val_loss did not improve from 0.16714\n",
        "Epoch 124/200\n",
        "127/127 - 161s - loss: 0.0838 - val_loss: 0.1694\n",
        "\n",
        "Epoch 00124: val_loss did not improve from 0.16714\n",
        "Epoch 125/200\n",
        "127/127 - 161s - loss: 0.0796 - val_loss: 0.1727\n",
        "\n",
        "V10: add TransformerEncoder to all layer with Multiply\n",
        "\n",
        "Epoch 164/200\n",
        "253/253 - 387s - loss: 0.0568 - val_loss: 0.1679\n",
        "\n",
        "Epoch 00164: val_loss did not improve from 0.16158\n",
        "Restoring model weights from the end of the best epoch.\n",
        "Epoch 00164: early stopping\n",
        "Fold-1 | OOF Score: 0.16158229343436334\n",
        "\n",
        "V10: analy_predict.\n",
        "\n",
        "Here is analyze result for V4:\n",
        "20__10 - MAE  0.16386306650915122, count: 25870\n",
        "20__20 - MAE  0.15764106283234391, count: 26272\n",
        "20__50 - MAE  0.16384391190488698, count: 34729\n",
        "50__10 - MAE  0.1585241009544335, count: 60574\n",
        "50__20 - MAE  0.24078390163257296, count: 37108\n",
        "50__50 - MAE  0.23760641023725088, count: 34699\n",
        "5__10 - MAE  0.15540978004136713, count: 36361\n",
        "5__20 - MAE  0.10102388763185534, count: 35935\n",
        "5__50 - MAE  0.11535413256937187, count: 35522\n",
        "\n",
        "\n",
        "V11: add dnn_model_GaussianNoise(), no improve\n",
        "\n",
        "Epoch 00183: val_loss did not improve from 0.16240\n",
        "Epoch 184/200\n",
        "127/127 - 150s - loss: 0.0498 - val_loss: 0.1642\n",
        "\n",
        "Epoch 00184: ReduceLROnPlateau reducing learning rate to 7.508467933803331e-05.\n",
        "\n",
        "Epoch 00184: val_loss did not improve from 0.16240\n",
        "Restoring model weights from the end of the best epoch.\n",
        "Epoch 00184: early stopping\n",
        "Fold-1 | OOF Score: 0.16240143234043636\n",
        "\n",
        "V12: dnn_model_aen(), use auto encoder to remove noise and learn encode.\n",
        "\n",
        "Epoch 200/200\n",
        "127/127 - 153s - loss: 4.1734 - decoder_loss: 3.8822 - ae_action_loss: 0.2257 - output_loss: 0.0654 - val_loss: 0.7126 - val_decoder_loss: 0.3742 - val_ae_action_loss: 0.1702 - val_output_loss: 0.1682\n",
        "\n",
        "Epoch 00200: val_loss did not improve from 0.69120\n",
        "\n",
        "Fold-1 | OOF Score: 0.16817480317739367\n",
        "20__10 - MAE  0.16644539428012722, count: 25870\n",
        "20__20 - MAE  0.15768315124243204, count: 26272\n",
        "20__50 - MAE  0.16684243562006307, count: 34729\n",
        "50__10 - MAE  0.16641273893399433, count: 60574\n",
        "50__20 - MAE  0.2518146440943941, count: 37108\n",
        "50__50 - MAE  0.2752187431993935, count: 34699\n",
        "5__10 - MAE  0.16763255549569941, count: 36361\n",
        "5__20 - MAE  0.10697168010290617, count: 35935\n",
        "5__50 - MAE  0.11503387157283243, count: 35522\n",
        "\n",
        "decoder_loss is very large. It means GaussianNoise() and dropout causes side effect.\n",
        "\n",
        "V13. Remove GaussianNoise and dropout, use encoder feature only. CV score is a little worse.\n",
        "\n",
        "Epoch 200/200\n",
        "127/127 - 150s - loss: 0.5841 - decoder_loss: 0.3983 - ae_action_loss: 0.1025 - output_loss: 0.0832 - val_loss: 0.4930 - val_decoder_loss: 0.1541 - val_ae_action_loss: 0.1693 - val_output_loss: 0.1696\n",
        "\n",
        "Epoch 00200: val_output_loss did not improve from 0.16793\n",
        "Fold-1 | OOF Score: 0.16959694784227083\n",
        "20__10 - MAE  0.18958046275757853, count: 25870\n",
        "20__20 - MAE  0.16960937531364753, count: 26272\n",
        "20__50 - MAE  0.1714088869810135, count: 34729\n",
        "50__10 - MAE  0.17159657573233353, count: 60574\n",
        "50__20 - MAE  0.2590598477978727, count: 37108\n",
        "50__50 - MAE  0.26932839218852966, count: 34699\n",
        "5__10 - MAE  0.16335297055531042, count: 36361\n",
        "5__20 - MAE  0.11217990298083265, count: 35935\n",
        "5__50 - MAE  0.12327488392594069, count: 35522\n",
        "\n",
        "V14: add RC_loss\n",
        "\n",
        "V15: change weight of RC_loss to 50\n",
        "Epoch 00209: val_loss did not improve from 2.45837\n",
        "Epoch 210/300\n",
        "Fold-1 | OOF Score: 0.1673458640660445\n",
        "20__10 - MAE  0.16871429221171652, count: 25870\n",
        "20__20 - MAE  0.17440932964643532, count: 26272\n",
        "20__50 - MAE  0.172235793440684, count: 34729\n",
        "50__10 - MAE  0.17126511889137416, count: 60574\n",
        "50__20 - MAE  0.2432283477323368, count: 37108\n",
        "50__50 - MAE  0.2597899337166222, count: 34699\n",
        "5__10 - MAE  0.16038654333096616, count: 36361\n",
        "5__20 - MAE  0.11624601028942623, count: 35935\n",
        "5__50 - MAE  0.12415466606839251, count: 35522\n",
        "\n",
        "V16: add transformer-lstm"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uslq2jL49nGk",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8b3a4c5d-145c-4afa-9ac4-fbcfaabf19eb"
      },
      "source": [
        "# Update pandas version for Colab TPU\n",
        "!pip install pandas==1.3.2"
      ],
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: pandas==1.3.2 in /usr/local/lib/python3.7/dist-packages (1.3.2)\n",
            "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas==1.3.2) (2018.9)\n",
            "Requirement already satisfied: python-dateutil>=2.7.3 in /usr/local/lib/python3.7/dist-packages (from pandas==1.3.2) (2.8.2)\n",
            "Requirement already satisfied: numpy>=1.17.3 in /usr/local/lib/python3.7/dist-packages (from pandas==1.3.2) (1.19.5)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.7.3->pandas==1.3.2) (1.15.0)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RBJlpUNI9com"
      },
      "source": [
        "## Import libraries"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iXzLriPA9coq"
      },
      "source": [
        "try:\n",
        "  import google.colab\n",
        "  IN_COLAB = True\n",
        "except:\n",
        "  IN_COLAB = False\n",
        "\n",
        "LOAD_PRE_FEATURE = True"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9esF__aG9cor",
        "outputId": "8c913d7e-dade-4920-ce5b-50a366bf6448"
      },
      "source": [
        "if IN_COLAB:\n",
        "  from google.colab import drive\n",
        "  drive.mount(\"/gdrive\", force_remount=True)"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /gdrive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MZ_f3Z2M9cos",
        "outputId": "2582e423-9036-4228-cbf3-4158530441b4"
      },
      "source": [
        "if IN_COLAB:\n",
        "  !pip install kaggle\n",
        "  !mkdir /root/.kaggle\n",
        "  !cp /gdrive/MyDrive/ventilator-pressure-prediction/kaggle.json /root/.kaggle\n",
        "  !kaggle competitions download -c ventilator-pressure-prediction\n",
        "  !kaggle datasets download -d  ventilatorpressurepredictionfeatures\n",
        "  !mkdir -p ../input/ventilator-pressure-prediction\n",
        "  !unzip '*.zip' -d ../input/ventilator-pressure-prediction\n",
        "  !ls ../input/ventilator-pressure-prediction\n",
        "  !mkdir -p ../input/ventilatorpressurepredictionfeatures/\n",
        "  !mv ../input/ventilator-pressure-prediction/*.npy ../input/ventilatorpressurepredictionfeatures\n",
        "  !mkdir /gdrive/MyDrive/ventilator-pressure-prediction/transformer_encoder_lstm_tpu\n",
        "  #Map Google driver folder to local folder model to save model\n",
        "  !ln -s /gdrive/MyDrive/ventilator-pressure-prediction/transformer_encoder_lstm_tpu model-gpu\n",
        "else:\n",
        "  !mkdir ./model-gpu\n",
        "  "
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: kaggle in /usr/local/lib/python3.7/dist-packages (1.5.12)\n",
            "Requirement already satisfied: six>=1.10 in /usr/local/lib/python3.7/dist-packages (from kaggle) (1.15.0)\n",
            "Requirement already satisfied: certifi in /usr/local/lib/python3.7/dist-packages (from kaggle) (2021.5.30)\n",
            "Requirement already satisfied: python-dateutil in /usr/local/lib/python3.7/dist-packages (from kaggle) (2.8.2)\n",
            "Requirement already satisfied: urllib3 in /usr/local/lib/python3.7/dist-packages (from kaggle) (1.24.3)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from kaggle) (2.23.0)\n",
            "Requirement already satisfied: python-slugify in /usr/local/lib/python3.7/dist-packages (from kaggle) (5.0.2)\n",
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (from kaggle) (4.62.3)\n",
            "Requirement already satisfied: text-unidecode>=1.3 in /usr/local/lib/python3.7/dist-packages (from python-slugify->kaggle) (1.3)\n",
            "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->kaggle) (3.0.4)\n",
            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->kaggle) (2.10)\n",
            "Warning: Looks like you're using an outdated API Version, please consider updating (server 1.5.12 / client 1.5.4)\n",
            "Downloading test.csv.zip to /content\n",
            " 88% 66.0M/75.4M [00:01<00:00, 48.5MB/s]\n",
            "100% 75.4M/75.4M [00:01<00:00, 65.0MB/s]\n",
            "Downloading train.csv.zip to /content\n",
            " 88% 123M/139M [00:01<00:00, 95.1MB/s]\n",
            "100% 139M/139M [00:01<00:00, 93.1MB/s]\n",
            "Downloading sample_submission.csv.zip to /content\n",
            "  0% 0.00/8.50M [00:00<?, ?B/s]\n",
            "100% 8.50M/8.50M [00:00<00:00, 78.0MB/s]\n",
            "Downloading ventilatorpressurepredictionfeatures.zip to /content\n",
            "100% 1.95G/1.95G [00:23<00:00, 89.3MB/s]\n",
            "100% 1.95G/1.95G [00:23<00:00, 89.1MB/s]\n",
            "Archive:  test.csv.zip\n",
            "  inflating: ../input/ventilator-pressure-prediction/test.csv  \n",
            "\n",
            "Archive:  sample_submission.csv.zip\n",
            "  inflating: ../input/ventilator-pressure-prediction/sample_submission.csv  \n",
            "\n",
            "Archive:  train.csv.zip\n",
            "  inflating: ../input/ventilator-pressure-prediction/train.csv  \n",
            "\n",
            "Archive:  ventilatorpressurepredictionfeatures.zip\n",
            "  inflating: ../input/ventilator-pressure-prediction/test.npy  \n",
            "  inflating: ../input/ventilator-pressure-prediction/train.npy  \n",
            "\n",
            "4 archives were successfully processed.\n",
            "sample_submission.csv  test.csv  test.npy  train.csv  train.npy\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-10-21T17:30:55.782617Z",
          "iopub.execute_input": "2021-10-21T17:30:55.783998Z",
          "iopub.status.idle": "2021-10-21T17:30:55.793669Z",
          "shell.execute_reply.started": "2021-10-21T17:30:55.783937Z",
          "shell.execute_reply": "2021-10-21T17:30:55.792667Z"
        },
        "trusted": true,
        "id": "1TfjZidC9cos"
      },
      "source": [
        "import gc\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import random\n",
        "import os\n",
        "from sklearn.model_selection import KFold\n",
        "from sklearn.preprocessing import RobustScaler, MinMaxScaler\n",
        "from sklearn.metrics import mean_absolute_error\n",
        "\n",
        "import tensorflow as tf\n",
        "gpus = tf.config.experimental.list_physical_devices('GPU')\n",
        "for gpu in gpus:\n",
        "  tf.config.experimental.set_memory_growth(gpu, True)\n",
        "from tensorflow.keras import backend as K\n",
        "\n",
        "from tensorflow.keras.utils import plot_model\n",
        "from tensorflow.keras.models import Model, load_model\n",
        "from tensorflow.keras.callbacks import EarlyStopping\n",
        "from tensorflow.keras.callbacks import ModelCheckpoint\n",
        "from tensorflow.keras.callbacks import ReduceLROnPlateau\n",
        "from tensorflow.keras.layers import BatchNormalization\n",
        "from tensorflow.keras.layers import Dense, Dropout, Input\n",
        "from tensorflow.keras.layers import Concatenate, LSTM, GRU\n",
        "from tensorflow.keras.layers import Bidirectional, Multiply\n",
        "\n",
        "\n",
        "\n",
        "# Random Seed Initialize\n",
        "RANDOM_SEED = 42\n",
        "\n",
        "def seed_everything(seed=RANDOM_SEED):\n",
        "    os.environ['PYTHONHASHSEED'] = str(seed)\n",
        "    np.random.seed(seed)\n",
        "    random.seed(seed)\n",
        "    tf.random.set_seed(seed)\n",
        "    \n",
        "seed_everything()"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XycyrO7g9cot"
      },
      "source": [
        "## Load datasets"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-10-21T17:24:55.352925Z",
          "iopub.execute_input": "2021-10-21T17:24:55.353455Z",
          "iopub.status.idle": "2021-10-21T17:25:06.101910Z",
          "shell.execute_reply.started": "2021-10-21T17:24:55.353418Z",
          "shell.execute_reply": "2021-10-21T17:25:06.100969Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 220
        },
        "id": "p_vUMe_39cot",
        "outputId": "32c6ea16-5ca7-49ab-eeee-263df03b4760"
      },
      "source": [
        "train_df = pd.read_csv('../input/ventilator-pressure-prediction/train.csv')\n",
        "print(f\"train_df: {train_df.shape}\")\n",
        "train_df.head()"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "train_df: (6036000, 8)\n"
          ]
        },
        {
          "output_type": "execute_result",
          "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>breath_id</th>\n",
              "      <th>R</th>\n",
              "      <th>C</th>\n",
              "      <th>time_step</th>\n",
              "      <th>u_in</th>\n",
              "      <th>u_out</th>\n",
              "      <th>pressure</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "      <td>20</td>\n",
              "      <td>50</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.083334</td>\n",
              "      <td>0</td>\n",
              "      <td>5.837492</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>2</td>\n",
              "      <td>1</td>\n",
              "      <td>20</td>\n",
              "      <td>50</td>\n",
              "      <td>0.033652</td>\n",
              "      <td>18.383041</td>\n",
              "      <td>0</td>\n",
              "      <td>5.907794</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>3</td>\n",
              "      <td>1</td>\n",
              "      <td>20</td>\n",
              "      <td>50</td>\n",
              "      <td>0.067514</td>\n",
              "      <td>22.509278</td>\n",
              "      <td>0</td>\n",
              "      <td>7.876254</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>4</td>\n",
              "      <td>1</td>\n",
              "      <td>20</td>\n",
              "      <td>50</td>\n",
              "      <td>0.101542</td>\n",
              "      <td>22.808822</td>\n",
              "      <td>0</td>\n",
              "      <td>11.742872</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>5</td>\n",
              "      <td>1</td>\n",
              "      <td>20</td>\n",
              "      <td>50</td>\n",
              "      <td>0.135756</td>\n",
              "      <td>25.355850</td>\n",
              "      <td>0</td>\n",
              "      <td>12.234987</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "   id  breath_id   R   C  time_step       u_in  u_out   pressure\n",
              "0   1          1  20  50   0.000000   0.083334      0   5.837492\n",
              "1   2          1  20  50   0.033652  18.383041      0   5.907794\n",
              "2   3          1  20  50   0.067514  22.509278      0   7.876254\n",
              "3   4          1  20  50   0.101542  22.808822      0  11.742872\n",
              "4   5          1  20  50   0.135756  25.355850      0  12.234987"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-10-21T17:25:11.213742Z",
          "iopub.execute_input": "2021-10-21T17:25:11.214675Z",
          "iopub.status.idle": "2021-10-21T17:25:11.297152Z",
          "shell.execute_reply.started": "2021-10-21T17:25:11.214617Z",
          "shell.execute_reply": "2021-10-21T17:25:11.295985Z"
        },
        "trusted": true,
        "id": "R5oBMjYJ9cov",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "23584e83-26a0-4c72-c43c-39409080fde6"
      },
      "source": [
        "all_pressure = np.sort(train_df['pressure'].unique())\n",
        "pressure_min =  all_pressure[0].item()\n",
        "pressure_max = all_pressure[-1].item()\n",
        "pressure_step = (all_pressure[1] - all_pressure[0]).item()\n",
        "\n",
        "pressure_min,pressure_max,pressure_step"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(-1.895744294564641, 64.8209917386395, 0.07030214545121005)"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "80hIcGg09cou"
      },
      "source": [
        "DEBUG = False\n",
        "\n",
        "if DEBUG:\n",
        "    train_df = train_df[:80*10000]\n",
        "\n",
        "targets = train_df[['pressure']].to_numpy().reshape(-1, 80)"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-10-21T17:25:06.103441Z",
          "iopub.execute_input": "2021-10-21T17:25:06.104426Z",
          "iopub.status.idle": "2021-10-21T17:25:11.211412Z",
          "shell.execute_reply.started": "2021-10-21T17:25:06.104376Z",
          "shell.execute_reply": "2021-10-21T17:25:11.209506Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 220
        },
        "id": "y-0XhQ3a9cov",
        "outputId": "3a93e7a6-b38a-419b-f98b-c8bbb1b63e52"
      },
      "source": [
        "test_df = pd.read_csv('../input/ventilator-pressure-prediction/test.csv')\n",
        "print(f\"test_df: {test_df.shape}\")\n",
        "test_df.head()"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "test_df: (4024000, 7)\n"
          ]
        },
        {
          "output_type": "execute_result",
          "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>breath_id</th>\n",
              "      <th>R</th>\n",
              "      <th>C</th>\n",
              "      <th>time_step</th>\n",
              "      <th>u_in</th>\n",
              "      <th>u_out</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>5</td>\n",
              "      <td>20</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>2</td>\n",
              "      <td>0</td>\n",
              "      <td>5</td>\n",
              "      <td>20</td>\n",
              "      <td>0.031904</td>\n",
              "      <td>7.515046</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>3</td>\n",
              "      <td>0</td>\n",
              "      <td>5</td>\n",
              "      <td>20</td>\n",
              "      <td>0.063827</td>\n",
              "      <td>14.651675</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>4</td>\n",
              "      <td>0</td>\n",
              "      <td>5</td>\n",
              "      <td>20</td>\n",
              "      <td>0.095751</td>\n",
              "      <td>21.230610</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>5</td>\n",
              "      <td>0</td>\n",
              "      <td>5</td>\n",
              "      <td>20</td>\n",
              "      <td>0.127644</td>\n",
              "      <td>26.320956</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "   id  breath_id  R   C  time_step       u_in  u_out\n",
              "0   1          0  5  20   0.000000   0.000000      0\n",
              "1   2          0  5  20   0.031904   7.515046      0\n",
              "2   3          0  5  20   0.063827  14.651675      0\n",
              "3   4          0  5  20   0.095751  21.230610      0\n",
              "4   5          0  5  20   0.127644  26.320956      0"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IVPWgQDL9cow"
      },
      "source": [
        "## Feature Engineering"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-10-21T17:25:11.298767Z",
          "iopub.execute_input": "2021-10-21T17:25:11.299164Z",
          "iopub.status.idle": "2021-10-21T17:27:48.006762Z",
          "shell.execute_reply.started": "2021-10-21T17:25:11.299125Z",
          "shell.execute_reply": "2021-10-21T17:27:48.005658Z"
        },
        "trusted": true,
        "id": "1NHNQSZp9cow"
      },
      "source": [
        "def add_features(df):\n",
        "    df['cross']= df['u_in'] * df['u_out']\n",
        "    df['cross2']= df['time_step'] * df['u_out']\n",
        "    df['area'] = df['time_step'] * df['u_in']\n",
        "    df['area'] = df.groupby('breath_id')['area'].cumsum()\n",
        "    df['time_step_cumsum'] = df.groupby(['breath_id'])['time_step'].cumsum()\n",
        "    df['u_in_cumsum'] = (df['u_in']).groupby(df['breath_id']).cumsum()\n",
        "    print(\"Step-1...Completed\")\n",
        "    \n",
        "    df['u_in_lag1'] = df.groupby('breath_id')['u_in'].shift(1)\n",
        "    df['u_out_lag1'] = df.groupby('breath_id')['u_out'].shift(1)\n",
        "    df['u_in_lag_back1'] = df.groupby('breath_id')['u_in'].shift(-1)\n",
        "    df['u_out_lag_back1'] = df.groupby('breath_id')['u_out'].shift(-1)\n",
        "    df['u_in_lag2'] = df.groupby('breath_id')['u_in'].shift(2)\n",
        "    df['u_out_lag2'] = df.groupby('breath_id')['u_out'].shift(2)\n",
        "    df['u_in_lag_back2'] = df.groupby('breath_id')['u_in'].shift(-2)\n",
        "    df['u_out_lag_back2'] = df.groupby('breath_id')['u_out'].shift(-2)\n",
        "    df['u_in_lag3'] = df.groupby('breath_id')['u_in'].shift(3)\n",
        "    df['u_out_lag3'] = df.groupby('breath_id')['u_out'].shift(3)\n",
        "    df['u_in_lag_back3'] = df.groupby('breath_id')['u_in'].shift(-3)\n",
        "    df['u_out_lag_back3'] = df.groupby('breath_id')['u_out'].shift(-3)\n",
        "    df['u_in_lag4'] = df.groupby('breath_id')['u_in'].shift(4)\n",
        "    df['u_out_lag4'] = df.groupby('breath_id')['u_out'].shift(4)\n",
        "    df['u_in_lag_back4'] = df.groupby('breath_id')['u_in'].shift(-4)\n",
        "    df['u_out_lag_back4'] = df.groupby('breath_id')['u_out'].shift(-4)\n",
        "    df = df.fillna(0)\n",
        "    print(\"Step-2...Completed\")\n",
        "    \n",
        "    df['breath_id__u_in__max'] = df.groupby(['breath_id'])['u_in'].transform('max')\n",
        "    df['breath_id__u_out__max'] = df.groupby(['breath_id'])['u_out'].transform('max')\n",
        "    df['breath_id__u_in__diffmax'] = df.groupby(['breath_id'])['u_in'].transform('max') - df['u_in']\n",
        "    df['breath_id__u_in__diffmean'] = df.groupby(['breath_id'])['u_in'].transform('mean') - df['u_in']\n",
        "    df['breath_id__u_in__diffmax'] = df.groupby(['breath_id'])['u_in'].transform('max') - df['u_in']\n",
        "    df['breath_id__u_in__diffmean'] = df.groupby(['breath_id'])['u_in'].transform('mean') - df['u_in']\n",
        "    print(\"Step-3...Completed\")\n",
        "    \n",
        "    df['u_in_diff1'] = df['u_in'] - df['u_in_lag1']\n",
        "    df['u_out_diff1'] = df['u_out'] - df['u_out_lag1']\n",
        "    df['u_in_diff2'] = df['u_in'] - df['u_in_lag2']\n",
        "    df['u_out_diff2'] = df['u_out'] - df['u_out_lag2']\n",
        "    df['u_in_diff3'] = df['u_in'] - df['u_in_lag3']\n",
        "    df['u_out_diff3'] = df['u_out'] - df['u_out_lag3']\n",
        "    df['u_in_diff4'] = df['u_in'] - df['u_in_lag4']\n",
        "    df['u_out_diff4'] = df['u_out'] - df['u_out_lag4']\n",
        "    print(\"Step-4...Completed\")\n",
        "    \n",
        "    df['one'] = 1\n",
        "    df['count'] = (df['one']).groupby(df['breath_id']).cumsum()\n",
        "    df['u_in_cummean'] =df['u_in_cumsum'] /df['count']\n",
        "    \n",
        "    df['breath_id_lag']=df['breath_id'].shift(1).fillna(0)\n",
        "    df['breath_id_lag2']=df['breath_id'].shift(2).fillna(0)\n",
        "    df['breath_id_lagsame']=np.select([df['breath_id_lag']==df['breath_id']],[1],0)\n",
        "    df['breath_id_lag2same']=np.select([df['breath_id_lag2']==df['breath_id']],[1],0)\n",
        "    df['breath_id__u_in_lag'] = df['u_in'].shift(1).fillna(0)\n",
        "    df['breath_id__u_in_lag'] = df['breath_id__u_in_lag'] * df['breath_id_lagsame']\n",
        "    df['breath_id__u_in_lag2'] = df['u_in'].shift(2).fillna(0)\n",
        "    df['breath_id__u_in_lag2'] = df['breath_id__u_in_lag2'] * df['breath_id_lag2same']\n",
        "    print(\"Step-5...Completed\")\n",
        "    \n",
        "    df['time_step_diff'] = df.groupby('breath_id')['time_step'].diff().fillna(0)\n",
        "    df['ewm_u_in_mean'] = (df\\\n",
        "                           .groupby('breath_id')['u_in']\\\n",
        "                           .ewm(halflife=9)\\\n",
        "                           .mean()\\\n",
        "                           .reset_index(level=0,drop=True))\n",
        "    df[[\"15_in_sum\",\"15_in_min\",\"15_in_max\",\"15_in_mean\"]] = (df\\\n",
        "                                                              .groupby('breath_id')['u_in']\\\n",
        "                                                              .rolling(window=15,min_periods=1)\\\n",
        "                                                              .agg({\"15_in_sum\":\"sum\",\n",
        "                                                                    \"15_in_min\":\"min\",\n",
        "                                                                    \"15_in_max\":\"max\",\n",
        "                                                                    \"15_in_mean\":\"mean\"\n",
        "                                                                    #\"15_in_std\":\"std\"\n",
        "                                                               })\\\n",
        "                                                               .reset_index(level=0,drop=True))\n",
        "    print(\"Step-6...Completed\")\n",
        "    \n",
        "    #df['u_in_diff_1_2'] = df['u_in_lag1'] - df['u_in_lag2']\n",
        "    #df['u_out_diff_1_2'] = df['u_out_lag1'] - df['u_out_lag2']\n",
        "    #df['u_in_lagback_diff_1_2'] = df['u_in_lag_back1'] - df['u_in_lag_back2']\n",
        "    #df['u_out_lagback_diff_1_2'] = df['u_out_lag_back1'] - df['u_out_lag_back2']\n",
        "    \n",
        "    df['u_in_lagback_diff1'] = df['u_in'] - df['u_in_lag_back1']\n",
        "    df['u_out_lagback_diff1'] = df['u_out'] - df['u_out_lag_back1']\n",
        "    df['u_in_lagback_diff2'] = df['u_in'] - df['u_in_lag_back2']\n",
        "    df['u_out_lagback_diff2'] = df['u_out'] - df['u_out_lag_back2']\n",
        "    print(\"Step-7...Completed\")\n",
        "    \n",
        "    df['R_cat'] = df['R'].astype(str)\n",
        "    df['C_cat'] = df['C'].astype(str)\n",
        "    df['R__C'] = df[\"R\"].astype(str) + '__' + df[\"C\"].astype(str)\n",
        "    df = pd.get_dummies(df)\n",
        "    print(\"Step-8...Completed\")\n",
        "    \n",
        "    return df\n",
        "\n",
        "if not LOAD_PRE_FEATURE:\n",
        "  print(\"Train data...\\n\")\n",
        "  train = add_features(train_df)\n",
        "\n",
        "  print(\"\\nTest data...\\n\")\n",
        "  test = add_features(test_df)"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Zcyv-iig9co0",
        "outputId": "2c21f301-54f1-42c6-864c-c2a58e4ff8d7"
      },
      "source": [
        "del train_df\n",
        "del test_df\n",
        "gc.collect()"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "89"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qip05b0r9co0"
      },
      "source": [
        "if not LOAD_PRE_FEATURE:\n",
        "  train.drop(['pressure','id', 'breath_id','one','count',\n",
        "              'breath_id_lag','breath_id_lag2','breath_id_lagsame',\n",
        "              'breath_id_lag2same'], axis=1, inplace=True)\n",
        "\n",
        "  test = test.drop(['id', 'breath_id','one','count','breath_id_lag',\n",
        "                    'breath_id_lag2','breath_id_lagsame',\n",
        "                    'breath_id_lag2same'], axis=1)\n",
        "\n",
        "  print(f\"train: {train.shape} \\ntest: {test.shape}\")\n",
        "  train.head()"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OYWzQtL49co1",
        "outputId": "ea058217-ed51-4598-85be-0166d0c257b4"
      },
      "source": [
        "if not LOAD_PRE_FEATURE:\n",
        "  scaler = RobustScaler()\n",
        "  train = scaler.fit_transform(train)\n",
        "  test = scaler.transform(test)\n",
        "\n",
        "  train = train.reshape(-1, 80, train.shape[-1])\n",
        "  test = test.reshape(-1, 80, train.shape[-1])\n",
        "else:\n",
        "  train = np.load('../input/ventilatorpressurepredictionfeatures/train.npy')\n",
        "  test = np.load('../input/ventilatorpressurepredictionfeatures/test.npy')\n",
        "\n",
        "print(f\"train: {train.shape} \\ntest: {test.shape} \\ntargets: {targets.shape}\")"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "train: (75450, 80, 66) \n",
            "test: (50300, 80, 66) \n",
            "targets: (75450, 80)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VONzQKWBdixE"
      },
      "source": [
        "R_cat_20\tR_cat_5\tR_cat_50\tC_cat_10\tC_cat_20\tC_cat_50\tR__C_20__10\tR__C_20__20\tR__C_20__50\tR__C_50__10\tR__C_50__20\tR__C_50__50\tR__C_5__10\tR__C_5__20\tR__C_5__50"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qAMo89gTBbqU",
        "outputId": "0fe44155-baac-4ef4-e701-4838a0197730"
      },
      "source": [
        "train[:3, 0, :]"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 0.00000000e+00,  7.50000000e-01, -9.89052161e-01,\n",
              "        -9.37384450e-01, -1.00000000e+00,  0.00000000e+00,\n",
              "        -6.65541311e-01, -5.16580501e-01, -4.96657632e-01,\n",
              "        -7.25227791e-01, -8.64120606e-01, -1.00000000e+00,\n",
              "         2.89020724e+00, -1.00000000e+00, -8.42526591e-01,\n",
              "        -1.00000000e+00,  3.66402550e+00, -1.00000000e+00,\n",
              "        -8.19257888e-01, -1.00000000e+00,  3.74391547e+00,\n",
              "        -1.00000000e+00, -7.94151600e-01, -1.00000000e+00,\n",
              "         4.27782420e+00, -1.00000000e+00,  1.12207936e-01,\n",
              "         0.00000000e+00,  3.26940916e-01,  1.27386353e+00,\n",
              "         4.71408803e-01,  0.00000000e+00,  2.17993186e-01,\n",
              "         0.00000000e+00,  1.21027987e-01,  0.00000000e+00,\n",
              "         6.83146754e-02,  0.00000000e+00, -6.48438329e-01,\n",
              "        -8.64120606e-01, -8.42526591e-01, -1.54759382e+01,\n",
              "        -6.74414709e-01, -8.06258228e-01,  7.89341177e-03,\n",
              "        -4.28435589e-01, -6.68749817e-01, -1.24171952e+02,\n",
              "         0.00000000e+00, -6.75689043e+01,  0.00000000e+00,\n",
              "         1.00000000e+00,  0.00000000e+00,  0.00000000e+00,\n",
              "         0.00000000e+00,  0.00000000e+00,  1.00000000e+00,\n",
              "         0.00000000e+00,  0.00000000e+00,  1.00000000e+00,\n",
              "         0.00000000e+00,  0.00000000e+00,  0.00000000e+00,\n",
              "         0.00000000e+00,  0.00000000e+00,  0.00000000e+00],\n",
              "       [ 0.00000000e+00,  0.00000000e+00, -9.89052161e-01,\n",
              "         1.69886631e+00, -1.00000000e+00,  0.00000000e+00,\n",
              "        -6.65541311e-01, -5.16580501e-01, -4.96657632e-01,\n",
              "        -6.93368579e-01, -8.64120606e-01, -1.00000000e+00,\n",
              "         1.98375688e+00, -1.00000000e+00, -8.42526591e-01,\n",
              "        -1.00000000e+00,  1.66759161e+00, -1.00000000e+00,\n",
              "        -8.19257888e-01, -1.00000000e+00,  1.51578530e+00,\n",
              "        -1.00000000e+00, -7.94151600e-01, -1.00000000e+00,\n",
              "         1.61468559e+00, -1.00000000e+00, -2.33263833e-01,\n",
              "         0.00000000e+00, -4.03073965e-01, -1.27954654e+00,\n",
              "         7.55340661e+01,  0.00000000e+00,  3.89316910e+01,\n",
              "         0.00000000e+00,  2.52293431e+01,  0.00000000e+00,\n",
              "         1.74186111e+01,  0.00000000e+00,  4.24631929e-01,\n",
              "        -8.64120606e-01, -8.42526591e-01, -1.54759382e+01,\n",
              "         1.23221688e+00, -6.47954643e-01,  2.88771552e+00,\n",
              "         6.35990341e-01,  1.21524300e+00, -1.21453746e+01,\n",
              "         0.00000000e+00, -1.14038297e+00,  0.00000000e+00,\n",
              "         1.00000000e+00,  0.00000000e+00,  0.00000000e+00,\n",
              "         0.00000000e+00,  1.00000000e+00,  0.00000000e+00,\n",
              "         0.00000000e+00,  1.00000000e+00,  0.00000000e+00,\n",
              "         0.00000000e+00,  0.00000000e+00,  0.00000000e+00,\n",
              "         0.00000000e+00,  0.00000000e+00,  0.00000000e+00],\n",
              "       [ 6.66666667e-01,  0.00000000e+00, -9.89052161e-01,\n",
              "        -9.55539088e-01, -1.00000000e+00,  0.00000000e+00,\n",
              "        -6.65541311e-01, -5.16580501e-01, -4.96657632e-01,\n",
              "        -7.25447190e-01, -8.64120606e-01, -1.00000000e+00,\n",
              "         5.85230064e-01, -1.00000000e+00, -8.42526591e-01,\n",
              "        -1.00000000e+00,  1.82123950e+00, -1.00000000e+00,\n",
              "        -8.19257888e-01, -1.00000000e+00,  2.59800328e+00,\n",
              "        -1.00000000e+00, -7.94151600e-01, -1.00000000e+00,\n",
              "         2.86855243e+00, -1.00000000e+00, -1.27840434e-01,\n",
              "         0.00000000e+00,  5.42062162e-02,  5.88358917e-01,\n",
              "        -4.55129464e-02,  0.00000000e+00, -4.86101177e-02,\n",
              "         0.00000000e+00, -5.18813481e-02,  0.00000000e+00,\n",
              "        -5.11687786e-02,  0.00000000e+00, -6.55828066e-01,\n",
              "        -8.64120606e-01, -8.42526591e-01, -1.54759382e+01,\n",
              "        -6.87544798e-01, -8.07348391e-01, -1.19385891e-02,\n",
              "        -4.35765797e-01, -6.81724002e-01, -4.87415356e+01,\n",
              "         0.00000000e+00, -4.01753866e+01,  0.00000000e+00,\n",
              "         0.00000000e+00,  0.00000000e+00,  1.00000000e+00,\n",
              "         0.00000000e+00,  1.00000000e+00,  0.00000000e+00,\n",
              "         0.00000000e+00,  0.00000000e+00,  0.00000000e+00,\n",
              "         0.00000000e+00,  1.00000000e+00,  0.00000000e+00,\n",
              "         0.00000000e+00,  0.00000000e+00,  0.00000000e+00]])"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2AQScob_Bg43"
      },
      "source": [
        "# np.save('train.npy', train)\n",
        "# np.save('test.npy', test)\n",
        "# !zip features.zip train.npy test.npy"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Osu14DeV9co1"
      },
      "source": [
        "## Hardware config"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CisxazED9co1",
        "outputId": "363fb860-645d-40af-aa82-b6d6e367c8fa"
      },
      "source": [
        "IS_TPU = False\n",
        "try:\n",
        "    tpu = tf.distribute.cluster_resolver.TPUClusterResolver()\n",
        "    tf.config.experimental_connect_to_cluster(tpu)\n",
        "    tf.tpu.experimental.initialize_tpu_system(tpu)\n",
        "    tpu_strategy = tf.distribute.experimental.TPUStrategy(tpu)\n",
        "    BATCH_SIZE = tpu_strategy.num_replicas_in_sync * 64\n",
        "    print(\"Running on TPU:\", tpu.master())\n",
        "    print(f\"Batch Size: {BATCH_SIZE}\")\n",
        "    IS_TPU = True    \n",
        "except ValueError:\n",
        "    tpu_strategy = tf.distribute.get_strategy()\n",
        "    BATCH_SIZE = 512\n",
        "    print(f\"Running on {tpu_strategy.num_replicas_in_sync} replicas\")\n",
        "    print(f\"Batch Size: {BATCH_SIZE}\")"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "INFO:tensorflow:Clearing out eager caches\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:tensorflow:Clearing out eager caches\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "INFO:tensorflow:Initializing the TPU system: grpc://10.83.165.42:8470\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:tensorflow:Initializing the TPU system: grpc://10.83.165.42:8470\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "INFO:tensorflow:Finished initializing TPU system.\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:tensorflow:Finished initializing TPU system.\n",
            "WARNING:absl:`tf.distribute.experimental.TPUStrategy` is deprecated, please use  the non experimental symbol `tf.distribute.TPUStrategy` instead.\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "INFO:tensorflow:Found TPU system:\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:tensorflow:Found TPU system:\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "INFO:tensorflow:*** Num TPU Cores: 8\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:tensorflow:*** Num TPU Cores: 8\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "INFO:tensorflow:*** Num TPU Workers: 1\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:tensorflow:*** Num TPU Workers: 1\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "INFO:tensorflow:*** Num TPU Cores Per Worker: 8\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:tensorflow:*** Num TPU Cores Per Worker: 8\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:localhost/replica:0/task:0/device:CPU:0, CPU, 0, 0)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:localhost/replica:0/task:0/device:CPU:0, CPU, 0, 0)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:CPU:0, CPU, 0, 0)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:CPU:0, CPU, 0, 0)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:0, TPU, 0, 0)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:0, TPU, 0, 0)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:1, TPU, 0, 0)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:1, TPU, 0, 0)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:2, TPU, 0, 0)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:2, TPU, 0, 0)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:3, TPU, 0, 0)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:3, TPU, 0, 0)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:4, TPU, 0, 0)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:4, TPU, 0, 0)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:5, TPU, 0, 0)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:5, TPU, 0, 0)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:6, TPU, 0, 0)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:6, TPU, 0, 0)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:7, TPU, 0, 0)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:7, TPU, 0, 0)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU_SYSTEM:0, TPU_SYSTEM, 0, 0)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU_SYSTEM:0, TPU_SYSTEM, 0, 0)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:XLA_CPU:0, XLA_CPU, 0, 0)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:XLA_CPU:0, XLA_CPU, 0, 0)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Running on TPU: grpc://10.83.165.42:8470\n",
            "Batch Size: 512\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GAZMw10A9co1"
      },
      "source": [
        "## Rescaling layer"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qLou5BDt9co2"
      },
      "source": [
        "@tf.custom_gradient\n",
        "def round_with_gradients(x):\n",
        "    def grad(dy):\n",
        "        return dy\n",
        "    return tf.round(x), grad\n",
        "\n",
        "class ScaleLayer(tf.keras.layers.Layer):\n",
        "    def __init__(self, **kwargs):\n",
        "        super(ScaleLayer, self).__init__(**kwargs)\n",
        "        self.min = tf.constant(pressure_min, dtype=np.float32)\n",
        "        self.max = tf.constant(pressure_max, dtype=np.float32)\n",
        "        self.step = tf.constant(pressure_step, dtype=np.float32)\n",
        "\n",
        "    def call(self, inputs):\n",
        "        steps = tf.math.divide(tf.math.add(inputs, -self.min), self.step)\n",
        "        int_steps = round_with_gradients(steps)\n",
        "        rescaled_steps = tf.math.add(tf.math.multiply(int_steps, self.step), self.min)\n",
        "        clipped = tf.clip_by_value(rescaled_steps, self.min, self.max)\n",
        "        return clipped\n",
        "    # def get_config(self):\n",
        "    #     return super(ScaleLayer, self).get_config()\n"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PfmPPh-U2EUY"
      },
      "source": [
        "class TransformerEncoder(tf.keras.layers.Layer):\n",
        "    def __init__(self, head_size, ff_dim, num_heads, dropout=0.3, **kwargs):\n",
        "        super().__init__(**kwargs)\n",
        "        self.embed_dim = head_size\n",
        "        self.dense_dim = ff_dim\n",
        "        self.num_heads = num_heads\n",
        "        self.dropout = dropout\n",
        "        self.attention_dropout = tf.keras.layers.Dropout(dropout)\n",
        "        self.attention = tf.keras.layers.MultiHeadAttention(\n",
        "            num_heads=num_heads, key_dim=head_size, dropout=dropout\n",
        "        )\n",
        "        self.attention_norm = tf.keras.layers.LayerNormalization(epsilon=1e-6)\n",
        "\n",
        "        self.ff_conv1 = tf.keras.layers.Conv1D(filters=ff_dim, kernel_size=1, activation='relu', name='ff_conv1')\n",
        "        self.ff_dropout = tf.keras.layers.Dropout(dropout)\n",
        "        self.ff_norm = tf.keras.layers.LayerNormalization(epsilon=1e-6)\n",
        "\n",
        "    def build(self, input_shape):\n",
        "      self.ff_conv2 = tf.keras.layers.Conv1D(filters=input_shape[-1], kernel_size=1, name='ff_conv2')\n",
        "\n",
        "    def call(self, inputs, mask=None):\n",
        "        if mask is not None:\n",
        "            mask = mask[:, tf.newaxis, :]\n",
        "\n",
        "        attention_output = self.attention(inputs, inputs, attention_mask=mask)\n",
        "        attention_output = self.attention_dropout(attention_output)\n",
        "        proj_input = self.attention_norm(inputs + attention_output)\n",
        "        proj_output = self.ff_conv1(proj_input)\n",
        "        proj_output = self.ff_conv2(proj_output)\n",
        "        proj_output = self.ff_dropout(proj_output)\n",
        "        return self.ff_norm(inputs + proj_output)\n",
        "    \n",
        "    def get_config(self):\n",
        "        config = super(TransformerEncoder, self).get_config()\n",
        "        config.update({\"head_size\": self.embed_dim,\n",
        "            \"ff_dim\": self.dense_dim,\n",
        "            \"num_heads\": self.num_heads,\n",
        "            \"dropout\": self.dropout})\n",
        "        return config\n",
        "\n",
        "#refer to https://www.kaggle.com/aimanlim0/transformer-lstm\n",
        "class Time2Vec(tf.keras.layers.Layer):\n",
        "    def __init__(self, kernel_size=1, **kwargs):\n",
        "        super(Time2Vec, self).__init__(**kwargs)\n",
        "        self.k = kernel_size\n",
        "    \n",
        "    def build(self, input_shape):\n",
        "        # print(input_shape)\n",
        "        # trend\n",
        "        self.wb = self.add_weight(name='wb',shape=(input_shape[1],),initializer='uniform',trainable=True)\n",
        "        self.bb = self.add_weight(name='bb',shape=(input_shape[1],),initializer='uniform',trainable=True)\n",
        "        # periodic\n",
        "        self.wa = self.add_weight(name='wa',shape=(1, input_shape[1], self.k),initializer='uniform',trainable=True)\n",
        "        self.ba = self.add_weight(name='ba',shape=(1, input_shape[1], self.k),initializer='uniform',trainable=True)\n",
        "        super(Time2Vec, self).build(input_shape)\n",
        "    \n",
        "    def call(self, inputs, **kwargs):\n",
        "        bias = self.wb * inputs + self.bb\n",
        "        dp = K.dot(inputs, self.wa) + self.ba\n",
        "        wgts = K.sin(dp) # or K.cos(.)\n",
        "\n",
        "        ret = K.concatenate([K.expand_dims(bias, -1), wgts], -1)\n",
        "        ret = K.reshape(ret, (-1, inputs.shape[1]*(self.k+1)))\n",
        "        return ret\n",
        "    \n",
        "    def compute_output_shape(self, input_shape):\n",
        "        return (input_shape[0], input_shape[1]*(self.k + 1))\n",
        "\n",
        "    def get_config(self):\n",
        "        config = super(Time2Vec, self).get_config()\n",
        "        config.update({\n",
        "            \"kernel_size\": self.k\n",
        "            })\n",
        "        return config\n",
        "\n",
        "class ModelTrunk(tf.keras.Model):\n",
        "    def __init__(self, name='ModelTrunk', time2vec_dim=1, num_heads=2, head_size=128, ff_dim=None, num_layers=1, dropout=0, **kwargs):\n",
        "        super().__init__(name=name, **kwargs)\n",
        "        self.time2vec = Time2Vec(kernel_size=time2vec_dim)\n",
        "        if ff_dim is None:\n",
        "            ff_dim = head_size\n",
        "        self.dropout = dropout\n",
        "        self.attention_layers = [TransformerEncoder(num_heads=num_heads, head_size=head_size, ff_dim=ff_dim, dropout=dropout) for _ in range(num_layers)]\n",
        "        #self.pooling=tf.keras.layers.AveragePooling1D(pool_size=4,data_format='channels_first')\n",
        "        self.final_layer = tf.keras.Sequential([\n",
        "                Bidirectional(LSTM(256, return_sequences=True)),\n",
        "                Bidirectional(LSTM(256, return_sequences=True)),\n",
        "                Dense(128, activation='selu'),\n",
        "                Dense(1)])\n",
        "    def call(self, inputs):\n",
        "        time_embedding = tf.keras.layers.TimeDistributed(self.time2vec)(inputs)\n",
        "        #time_embedding=inputs\n",
        "        #print(time_embedding.shape)\n",
        "        x = K.concatenate([inputs, time_embedding], -1)\n",
        "        for attention_layer in self.attention_layers:\n",
        "            x = attention_layer(x)\n",
        "        x=self.final_layer(x)\n",
        "        return x\n",
        "\n",
        "def do_TransformerEncoder_LSTM(inputs, time2vec_dim=1, num_heads=2, head_size=128, ff_dim=None, num_layers=1, dropout=0):\n",
        "    time2vec = Time2Vec(kernel_size=time2vec_dim)\n",
        "    if ff_dim is None:\n",
        "        ff_dim = head_size\n",
        "    dropout = dropout\n",
        "    attention_layers = [TransformerEncoder(num_heads=num_heads, head_size=head_size, ff_dim=ff_dim, dropout=dropout) for _ in range(num_layers)]\n",
        "    #self.pooling=tf.keras.layers.AveragePooling1D(pool_size=4,data_format='channels_first')\n",
        "    final_layer = tf.keras.Sequential([\n",
        "            Bidirectional(LSTM(256, return_sequences=True)),\n",
        "            Bidirectional(LSTM(256, return_sequences=True)),\n",
        "            Dense(128, activation='selu')\n",
        "    ])\n",
        "    \n",
        "    time_embedding = tf.keras.layers.TimeDistributed(time2vec)(inputs)\n",
        "    x = K.concatenate([inputs, time_embedding], -1)\n",
        "    for attention_layer in attention_layers:\n",
        "        x = attention_layer(x)\n",
        "    x=final_layer(x)\n",
        "    return x\n",
        "\n",
        "\n",
        "class PositionalEmbedding(tf.keras.layers.Layer):\n",
        "    def __init__(self, sequence_length, vocab_size, embed_dim, **kwargs):\n",
        "        super(PositionalEmbedding, self).__init__(**kwargs)\n",
        "        self.token_embeddings = tf.keras.layers.Layer.Embedding(\n",
        "            input_dim=vocab_size, output_dim=embed_dim\n",
        "        )\n",
        "        self.position_embeddings = tf.keras.layers.Layer.Embedding(\n",
        "            input_dim=sequence_length, output_dim=embed_dim\n",
        "        )\n",
        "        self.sequence_length = sequence_length\n",
        "        self.vocab_size = vocab_size\n",
        "        self.embed_dim = embed_dim\n",
        "\n",
        "    def call(self, inputs):\n",
        "        length = tf.shape(inputs)[-1]\n",
        "        positions = tf.range(start=0, limit=length, delta=1)\n",
        "        embedded_tokens = self.token_embeddings(inputs)\n",
        "        embedded_positions = self.position_embeddings(positions)\n",
        "        return embedded_tokens + embedded_positions\n",
        "\n",
        "    def compute_mask(self, inputs, mask=None):\n",
        "        return tf.math.not_equal(inputs, 0)\n",
        "\n",
        "\n",
        "class TransformerDecoder(tf.keras.layers.Layer):\n",
        "    def __init__(self, embed_dim, latent_dim, num_heads, **kwargs):\n",
        "        super(TransformerDecoder, self).__init__(**kwargs)\n",
        "        self.embed_dim = embed_dim\n",
        "        self.latent_dim = latent_dim\n",
        "        self.num_heads = num_heads\n",
        "        self.attention_1 = tf.keras.layers.MultiHeadAttention(\n",
        "            num_heads=num_heads, key_dim=embed_dim\n",
        "        )\n",
        "        self.attention_2 = tf.keras.layers.MultiHeadAttention(\n",
        "            num_heads=num_heads, key_dim=embed_dim\n",
        "        )\n",
        "        self.dense_proj = tf.keras.Sequential(\n",
        "            [Dense(latent_dim, activation=\"relu\"), Dense(embed_dim),]\n",
        "        )\n",
        "        self.layernorm_1 = tf.keras.layers.LayerNormalization()\n",
        "        self.layernorm_2 = tf.keras.layers.LayerNormalization()\n",
        "        self.layernorm_3 = tf.keras.layers.LayerNormalization()\n",
        "        self.supports_masking = True\n",
        "\n",
        "    def call(self, inputs, encoder_outputs, mask=None):\n",
        "        causal_mask = self.get_causal_attention_mask(inputs)\n",
        "        padding_mask = None\n",
        "        if mask is not None:\n",
        "            padding_mask = tf.cast(mask[:, tf.newaxis, :], dtype=\"int32\")\n",
        "            padding_mask = tf.minimum(padding_mask, causal_mask)\n",
        "\n",
        "        attention_output_1 = self.attention_1(\n",
        "            query=inputs, value=inputs, key=inputs, attention_mask=causal_mask\n",
        "        )\n",
        "        out_1 = self.layernorm_1(inputs + attention_output_1)\n",
        "\n",
        "        attention_output_2 = self.attention_2(\n",
        "            query=out_1,\n",
        "            value=encoder_outputs,\n",
        "            key=encoder_outputs,\n",
        "            attention_mask=padding_mask,\n",
        "        )\n",
        "        out_2 = self.layernorm_2(out_1 + attention_output_2)\n",
        "\n",
        "        proj_output = self.dense_proj(out_2)\n",
        "        return self.layernorm_3(out_2 + proj_output)\n",
        "\n",
        "    def get_causal_attention_mask(self, inputs):\n",
        "        input_shape = tf.shape(inputs)\n",
        "        batch_size, sequence_length = input_shape[0], input_shape[1]\n",
        "        i = tf.range(sequence_length)[:, tf.newaxis]\n",
        "        j = tf.range(sequence_length)\n",
        "        mask = tf.cast(i >= j, dtype=\"int32\")\n",
        "        mask = tf.reshape(mask, (1, input_shape[1], input_shape[1]))\n",
        "        mult = tf.concat(\n",
        "            [tf.expand_dims(batch_size, -1), tf.constant([1, 1], dtype=tf.int32)],\n",
        "            axis=0,\n",
        "        )\n",
        "        return tf.tile(mask, mult)\n",
        "\n",
        "def TransformerEncoder_LSTM_model(time2vec_dim=1, num_heads=2, head_size=128, ff_dim=None, num_layers=1, dropout=0):\n",
        "    inputs = Input(shape=(train.shape[-2:]))\n",
        "    x = do_TransformerEncoder_LSTM(inputs, time2vec_dim, num_heads, head_size, ff_dim, num_layers, dropout)\n",
        "    x = Dense(1)(x)\n",
        "    x_output = ScaleLayer()(x)\n",
        "\n",
        "    model = Model(inputs=inputs, outputs=x_output, \n",
        "                  name='DNN_Model')\n",
        "    return model    \n",
        "    \n",
        "def Transformer_LSTM_model(time2vec_dim=1, num_heads=2, head_size=128, ff_dim=None, num_layers=1, dropout=0):\n",
        "    encoder_inputs = Input(shape=(train.shape[-2:]))\n",
        "    encoder_outputs = do_TransformerEncoder_LSTM(encoder_inputs, time2vec_dim, num_heads, head_size, ff_dim, num_layers, dropout)\n",
        "\n",
        "    encoder_model = Model(inputs=encoder_inputs, outputs=encoder_outputs, \n",
        "                  name='encoder_model')\n",
        "    \n",
        "    embed_dim = 128\n",
        "    latent_dim = 1024\n",
        "    decoder_inputs = Input(shape=(40,), name=\"decoder_inputs\")\n",
        "    encoded_seq_inputs = Input(shape=(80, embed_dim), name=\"decoder_state_inputs\")\n",
        "    \n",
        "    time2vec = Time2Vec(kernel_size=1)\n",
        "    time_embedding = tf.keras.layers.TimeDistributed(time2vec)\n",
        "    #Expand target and embeding with time. 80x2\n",
        "    x = K.expand_dims(decoder_inputs, -1)\n",
        "    x = time_embedding(x)\n",
        "    #Expand 80x2 to 80xembed_dim\n",
        "    x = Dense(embed_dim)(x)\n",
        "    \n",
        "    x = TransformerDecoder(embed_dim, latent_dim, num_heads)(x, encoded_seq_inputs)\n",
        "#     x = Dropout(0.5)(x)\n",
        "    x = Dense(128, activation='selu')(x)\n",
        "    decoder_outputs = Dense(1)(x)\n",
        "    decoder = Model([decoder_inputs, encoded_seq_inputs], decoder_outputs, name='decoder_model')\n",
        "    decoder.summary()\n",
        "    \n",
        "    decoder_outputs = decoder([decoder_inputs, encoder_outputs])\n",
        "    transformer = Model(\n",
        "        [encoder_inputs, decoder_inputs], decoder_outputs, name=\"transformer\"\n",
        "    )\n",
        "    \n",
        "    return transformer"
      ],
      "execution_count": 55,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "b_lJ_vH8KmZ8",
        "outputId": "020ea1c0-ea8c-49f6-ea4f-baedd4514dc6"
      },
      "source": [
        "model=ModelTrunk(ff_dim=256,num_heads=4,num_layers=2,)\n",
        "x=tf.random.uniform((64,80,66))\n",
        "x=model(x)\n",
        "print(x.shape)\n",
        "del model"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(64, 80, 1)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5Ft0JBPC9co2"
      },
      "source": [
        "## Keras DNN Model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wJn6J6temxSO"
      },
      "source": [
        "def dnn_model_v4():\n",
        "    \n",
        "    x_input = Input(shape=(train.shape[-2:]))\n",
        "    \n",
        "    x1 = Bidirectional(LSTM(units=768, return_sequences=True))(x_input)\n",
        "    x2 = Bidirectional(LSTM(units=512, return_sequences=True))(x1)\n",
        "    x3 = Bidirectional(LSTM(units=384, return_sequences=True))(x2)\n",
        "    x4 = Bidirectional(LSTM(units=256, return_sequences=True))(x3)\n",
        "    x5 = Bidirectional(LSTM(units=128, return_sequences=True))(x4)\n",
        "    \n",
        "    z2 = Bidirectional(GRU(units=384, return_sequences=True))(x2)\n",
        "    \n",
        "    z31 = Multiply()([x3, z2])\n",
        "    z31 = BatchNormalization()(z31)\n",
        "    z3 = Bidirectional(GRU(units=256, return_sequences=True))(z31)\n",
        "    \n",
        "    z41 = Multiply()([x4, z3])\n",
        "    z41 = BatchNormalization()(z41)\n",
        "    z4 = Bidirectional(GRU(units=128, return_sequences=True))(z41)\n",
        "    \n",
        "    z51 = Multiply()([x5, z4])\n",
        "    z51 = BatchNormalization()(z51)\n",
        "    z5 = Bidirectional(GRU(units=64, return_sequences=True))(z51)\n",
        "    \n",
        "    x = Concatenate(axis=2)([x5, z2, z3, z4, z5])\n",
        "    \n",
        "    x = Dense(units=128, activation='selu')(x)\n",
        "    \n",
        "    x_output = Dense(units=1)(x)\n",
        "    \n",
        "    x_output = ScaleLayer()(x_output)\n",
        "\n",
        "    model = Model(inputs=x_input, outputs=x_output, \n",
        "                  name='DNN_Model')\n",
        "    return model"
      ],
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1vvobI5X05Od"
      },
      "source": [
        "#refer to https://www.kaggle.com/masato114/vp-wavenet-training-gpu\n",
        "# def conv_block(x: tf.Tensor, filters: int, kernel_size: int):\n",
        "#     \"\"\"\n",
        "#     Implements convolution block with residual connection.\n",
        "#     :param x: Input tensor.\n",
        "#     :param filters: Number of filters in convolution layer.\n",
        "#     :param kernel_size: Filter size.\n",
        "#     :return: Output tensor.\n",
        "#     \"\"\"\n",
        "#     x = tf.keras.layers.Conv1D(filters=filters,\n",
        "#                kernel_size=1,\n",
        "#                padding='same')(x)\n",
        "#     res_x = x\n",
        "#     x = tf.keras.layers.Conv1D(filters=filters,\n",
        "#                kernel_size=kernel_size,\n",
        "#                padding='same', activation='relu')(x)\n",
        "#     x = tf.keras.layers.Conv1D(filters=filters,\n",
        "#                kernel_size=kernel_size,\n",
        "#                padding='same', activation='relu')(x)\n",
        "#     x = tf.keras.layers.Conv1D(filters=filters,\n",
        "#                kernel_size=kernel_size,\n",
        "#                padding='same', activation='relu')(x)\n",
        "#     res_x = tf.keras.layers.Add()([res_x, x])\n",
        "#     return res_x\n",
        "\n",
        "# def wave_block(x: tf.Tensor, filters: int, kernel_size: int, n: int):\n",
        "#     \"\"\"\n",
        "#     Implements wavenet block.\n",
        "#     :param x: Input tensor.\n",
        "#     :param filters: Number of kernels.\n",
        "#     :param kernel_size: Filter size.\n",
        "#     :param n: Number of dilation rates for convolutions.\n",
        "#     :return: Output tensor.\n",
        "#     \"\"\"\n",
        "#     dilation_rates = [2 ** i for i in range(n)]\n",
        "#     x = tf.keras.layers.Conv1D(filters=filters,\n",
        "#                kernel_size=1,\n",
        "#                padding='same')(x)\n",
        "#     res_x = x\n",
        "#     for dilation_rate in dilation_rates:\n",
        "#         tanh_out = tf.keras.layers.Conv1D(filters=filters,\n",
        "#                           kernel_size=kernel_size,\n",
        "#                           padding='same',\n",
        "#                           activation='tanh',\n",
        "#                           dilation_rate=dilation_rate)(x)\n",
        "#         sigm_out = tf.keras.layers.Conv1D(filters=filters,\n",
        "#                           kernel_size=kernel_size,\n",
        "#                           padding='same',\n",
        "#                           activation='sigmoid',\n",
        "#                           dilation_rate=dilation_rate)(x)\n",
        "#         x = tf.keras.layers.Multiply()([tanh_out, sigm_out])\n",
        "#         x = tf.keras.layers.Conv1D(filters=filters,\n",
        "#                    kernel_size=1,\n",
        "#                    padding='same')(x)\n",
        "#         res_x = tf.keras.layers.Add()([res_x, x])\n",
        "#     return res_x\n",
        "\n",
        "# def do_wavenet(inp):\n",
        "#     x = conv_block(inp, 16, 3)\n",
        "#     x = wave_block(x, 16, 3, 12)\n",
        "#     x = conv_block(x, 32, 3)\n",
        "#     x = wave_block(x, 32, 3, 8)\n",
        "#     x = conv_block(x, 64, 3)\n",
        "#     x = wave_block(x, 64, 3, 4)\n",
        "#     x = conv_block(x, 128, 3)\n",
        "#     x = wave_block(x, 128, 3, 1)\n",
        "#     return x\n",
        "\n",
        "#refer to https://www.kaggle.com/meminozturk/into-the-wild-wavenet/\n",
        "i_wavenet_layer = 0\n",
        "def wave_block(x, filters, kernel_size, n):\n",
        "    global i_wavenet_layer\n",
        "    dilation_rates = [2**i for i in range(n)]\n",
        "    x = tf.keras.layers.Conv1D(filters = filters,\n",
        "                kernel_size = 1,\n",
        "                padding = 'same')(x)\n",
        "    res_x = x\n",
        "    for dilation_rate in dilation_rates:\n",
        "        tanh_out = tf.keras.layers.Conv1D(filters = filters,\n",
        "                          kernel_size = kernel_size,\n",
        "                          padding = 'same', \n",
        "                          activation = 'tanh', \n",
        "                          dilation_rate = dilation_rate)(x)\n",
        "        sigm_out = tf.keras.layers.Conv1D(filters = filters,\n",
        "                          kernel_size = kernel_size,\n",
        "                          padding = 'same',\n",
        "                          activation = 'sigmoid', \n",
        "                          dilation_rate = dilation_rate)(x)\n",
        "        x = tf.keras.layers.Multiply(name=f'wavenet_Multiply_{i_wavenet_layer}')([tanh_out, sigm_out])\n",
        "        x = tf.keras.layers.Conv1D(filters = filters,\n",
        "                    kernel_size = 1,\n",
        "                    padding = 'same')(x)\n",
        "        res_x = tf.keras.layers.Add()([res_x, x])\n",
        "        i_wavenet_layer += 1\n",
        "    return res_x\n",
        "\n",
        "def do_wavenet(inp):\n",
        "  x = wave_block(inp, 16, 3, 8)\n",
        "  x = wave_block(x, 32, 3, 12)\n",
        "  x = wave_block(x, 64, 3, 4)\n",
        "  x = wave_block(x, 128, 3, 1)\n",
        "  return x\n",
        "\n",
        "def load_model_until(checkpoint_name, drop_idx=-4, retrain=False):\n",
        "  print('Load pretrain weight from ', checkpoint_name)\n",
        "  load_locally = tf.saved_model.LoadOptions(experimental_io_device='/job:localhost')\n",
        "  try:\n",
        "    # At loading time, register the custom objects with a `custom_object_scope`:\n",
        "    custom_objects = {\"ScaleLayer\": ScaleLayer}\n",
        "    with tf.keras.utils.custom_object_scope(custom_objects):\n",
        "        base_model = load_model(checkpoint_name, options=load_locally)\n",
        "  except (OSError):\n",
        "    print('Cannot load pretrain weight from ', checkpoint_name)\n",
        "\n",
        "  # base_model.summary()\n",
        "  base_output = base_model.layers[drop_idx].output\n",
        "  # Frozen layers\n",
        "  for layer in base_model.layers[0:drop_idx]:\n",
        "    layer.trainable = retrain\n",
        "\n",
        "  return base_model.inputs, base_output\n",
        "\n",
        "def load_dnn_model_v4_add_wavenet(drop_idx=-4, retrain=False):\n",
        "  base_inputs, base_output = load_model_until('/gdrive/MyDrive/ventilator-pressure-prediction/gb-rescaling-eda-v3/Bidirect_LSTM_model_1C.h5', drop_idx, \n",
        "                                              drop_idx=drop_idx, retrain=retrain)\n",
        "  \n",
        "  wavenet_output = do_wavenet(base_output)\n",
        "\n",
        "  global i_wavenet_layer\n",
        "  x_output = Dense(units=1, name=f'wavenet_Dense_{i_wavenet_layer}')(wavenet_output)\n",
        "  i_wavenet_layer += 1\n",
        "  x_output = ScaleLayer()(x_output)\n",
        "\n",
        "  new_model = tf.keras.models.Model(inputs=base_inputs, outputs=x_output)\n",
        "  # new_model.summary()\n",
        "\n",
        "  return new_model\n",
        "\n",
        "def lstm_wavenet_model():\n",
        "    x_input = Input(shape=(train.shape[-2:]))\n",
        "    \n",
        "    x1 = Bidirectional(LSTM(units=768, return_sequences=True))(x_input)\n",
        "    x2 = Bidirectional(LSTM(units=512, return_sequences=True))(x1)\n",
        "    x3 = Bidirectional(LSTM(units=384, return_sequences=True))(x2)\n",
        "    x4 = Bidirectional(LSTM(units=256, return_sequences=True))(x3)\n",
        "    x5 = Bidirectional(LSTM(units=128, return_sequences=True))(x4)\n",
        "    \n",
        "    z2 = Bidirectional(GRU(units=384, return_sequences=True))(x2)\n",
        "    \n",
        "    z31 = Multiply()([x3, z2])\n",
        "    z31 = BatchNormalization()(z31)\n",
        "    z3 = Bidirectional(GRU(units=256, return_sequences=True))(z31)\n",
        "    \n",
        "    z41 = Multiply()([x4, z3])\n",
        "    z41 = BatchNormalization()(z41)\n",
        "    z4 = Bidirectional(GRU(units=128, return_sequences=True))(z41)\n",
        "    \n",
        "    z51 = Multiply()([x5, z4])\n",
        "    z51 = BatchNormalization()(z51)\n",
        "    z5 = Bidirectional(GRU(units=64, return_sequences=True))(z51)\n",
        "    \n",
        "    x = Concatenate(axis=2)([x5, z2, z3, z4, z5])\n",
        "    \n",
        "    x = do_wavenet(x)\n",
        "    \n",
        "    x = Dense(units=128, activation='selu')(x)\n",
        "    x_output = Dense(units=1)(x)\n",
        "    \n",
        "    x_output = ScaleLayer()(x_output)\n",
        "\n",
        "    model = Model(inputs=x_input, outputs=x_output, \n",
        "                  name='lstm_wavenet_model')\n",
        "    return model"
      ],
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KwdrVcpdwjvc"
      },
      "source": [
        "def dnn_model_aen():\n",
        "    \n",
        "    x_input = Input(shape=(train.shape[-2:]))\n",
        "\n",
        "    x0 = tf.keras.layers.BatchNormalization()(x_input)\n",
        "    \n",
        "    #remove noise\n",
        "    # encoder = tf.keras.layers.GaussianNoise(0.03527936123679956)(x0)\n",
        "    encoder = tf.keras.layers.Dense(16)(x0)\n",
        "    encoder = tf.keras.layers.BatchNormalization()(encoder)\n",
        "    encoder = tf.keras.layers.Activation('swish')(encoder)\n",
        "    \n",
        "    decoder = tf.keras.layers.Dropout(0.0)(encoder)\n",
        "    decoder = tf.keras.layers.Dense(train.shape[-1], name = 'decoder')(decoder)\n",
        "\n",
        "\n",
        "    # x = tf.keras.layers.Concatenate()([x0, encoder])\n",
        "    x = encoder\n",
        "    \n",
        "    x1 = Bidirectional(LSTM(units=768, return_sequences=True))(x)\n",
        "    x2 = Bidirectional(LSTM(units=512, return_sequences=True))(x1)\n",
        "    x3 = Bidirectional(LSTM(units=384, return_sequences=True))(x2)\n",
        "    x4 = Bidirectional(LSTM(units=256, return_sequences=True))(x3)\n",
        "    x5 = Bidirectional(LSTM(units=128, return_sequences=True))(x4)\n",
        "\n",
        "    x_ae = tf.keras.layers.Dense(128, activation='swish')(x5)\n",
        "    x_ae = tf.keras.layers.Dropout(0.0)(x_ae)\n",
        "\n",
        "    out_ae = tf.keras.layers.Dense(1, name = 'ae_action')(x_ae)\n",
        "\n",
        "    z2 = Bidirectional(GRU(units=384, return_sequences=True))(x2)\n",
        "    \n",
        "    z31 = Multiply()([x3, z2])\n",
        "    z31 = BatchNormalization()(z31)\n",
        "    z3 = Bidirectional(GRU(units=256, return_sequences=True))(z31)\n",
        "    \n",
        "    z41 = Multiply()([x4, z3])\n",
        "    z41 = BatchNormalization()(z41)\n",
        "    z4 = Bidirectional(GRU(units=128, return_sequences=True))(z41)\n",
        "    \n",
        "    z51 = Multiply()([x5, z4])\n",
        "    z51 = BatchNormalization()(z51)\n",
        "    z5 = Bidirectional(GRU(units=64, return_sequences=True))(z51)\n",
        "    \n",
        "    x = Concatenate(axis=2)([x5, z2, z3, z4, z5])\n",
        "    \n",
        "    x = Dense(units=128, activation='swish')(x)\n",
        "    \n",
        "    x_output = Dense(units=1)(x)\n",
        "    \n",
        "    x_output = ScaleLayer(name = 'output')(x_output)\n",
        "\n",
        "    model = Model(inputs=x_input, outputs=[decoder, out_ae, x_output], \n",
        "                  name='dnn_model_aen')\n",
        "    return model"
      ],
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "82jplaDkoBg9"
      },
      "source": [
        "def dnn_model_GaussianNoise():\n",
        "    \n",
        "    x_input = Input(shape=(train.shape[-2:]))\n",
        "    \n",
        "    x1 = Bidirectional(LSTM(units=768, return_sequences=True))(x_input)\n",
        "    x2 = Bidirectional(LSTM(units=512, return_sequences=True))(x1)\n",
        "    x3 = Bidirectional(LSTM(units=384, return_sequences=True))(x2)\n",
        "    x4 = Bidirectional(LSTM(units=256, return_sequences=True))(x3)\n",
        "    x5 = Bidirectional(LSTM(units=128, return_sequences=True))(x4)\n",
        "    \n",
        "    z2 = Bidirectional(GRU(units=384, return_sequences=True))(x2)\n",
        "    \n",
        "    z31 = Multiply()([x3, z2])\n",
        "    z31 = BatchNormalization()(z31)\n",
        "    z31 = tf.keras.layers.GaussianNoise(0.035)(z31)\n",
        "    z3 = Bidirectional(GRU(units=256, return_sequences=True))(z31)\n",
        "    \n",
        "    z41 = Multiply()([x4, z3])\n",
        "    z41 = BatchNormalization()(z41)\n",
        "    z4 = Bidirectional(GRU(units=128, return_sequences=True))(z41)\n",
        "    \n",
        "    z51 = Multiply()([x5, z4])\n",
        "    z51 = BatchNormalization()(z51)\n",
        "    z5 = Bidirectional(GRU(units=64, return_sequences=True))(z51)\n",
        "    \n",
        "    x = Concatenate(axis=2)([x5, z2, z3, z4, z5])\n",
        "    \n",
        "    x = Dense(units=128, activation='selu')(x)\n",
        "    \n",
        "    x_output = Dense(units=1)(x)\n",
        "    \n",
        "    x_output = ScaleLayer()(x_output)\n",
        "\n",
        "    model = Model(inputs=x_input, outputs=x_output, \n",
        "                  name='dnn_model_GaussianNoise')\n",
        "    return model"
      ],
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_HuMFGY39co2"
      },
      "source": [
        "def dnn_TransformerEncoder_model():\n",
        "    \n",
        "    x_input = Input(shape=(train.shape[-2:]))\n",
        "    \n",
        "    x1 = Bidirectional(LSTM(units=768, return_sequences=True))(x_input)\n",
        "    x2 = Bidirectional(LSTM(units=512, return_sequences=True))(x1)\n",
        "    x3 = Bidirectional(LSTM(units=384, return_sequences=True))(x2)\n",
        "    x4 = Bidirectional(LSTM(units=256, return_sequences=True))(x3)\n",
        "    x5 = Bidirectional(LSTM(units=128, return_sequences=True))(x4)\n",
        "    \n",
        "    z2 = Bidirectional(GRU(units=384, return_sequences=True))(x2)\n",
        "\n",
        "    dropout_r = 0.01\n",
        "    \n",
        "    z31 = Multiply()([x3, z2])\n",
        "    z31 = BatchNormalization()(z31)\n",
        "    z31_transformer = TransformerEncoder(384*2, 512*2, 8, dropout_r, name=\"transformer_layer_z31\")(z31)\n",
        "    z31 = Multiply()([z31, z31_transformer])\n",
        "    \n",
        "    z3 = Bidirectional(GRU(units=256, return_sequences=True))(z31)\n",
        "    \n",
        "    z41 = Multiply()([x4, z3])\n",
        "    z41 = BatchNormalization()(z41)\n",
        "    z41_transformer = TransformerEncoder(256*2, 384*2, 8, dropout_r, name=\"transformer_layer_z41\")(z41)\n",
        "    z41 = Multiply()([z41, z41_transformer])\n",
        "    \n",
        "    z4 = Bidirectional(GRU(units=128, return_sequences=True))(z41)\n",
        "    \n",
        "    z51 = Multiply()([x5, z4])\n",
        "    z51 = BatchNormalization()(z51)\n",
        "    z51_transformer = TransformerEncoder(128*2, 256*2, 8, dropout_r, name=\"transformer_layer_z51\")(z51)\n",
        "    z51 = Multiply()([z51, z51_transformer])\n",
        "    \n",
        "    z5 = Bidirectional(GRU(units=64, return_sequences=True))(z51)\n",
        "    \n",
        "    x = Concatenate(axis=2)([x5, z2, z3, z4, z5])\n",
        "\n",
        "    x = Dense(units=128)(x)\n",
        "\n",
        "    x_transformer = BatchNormalization()(x)\n",
        "    x_transformer = TransformerEncoder(128, 512, 8, dropout_r, name=\"transformer_layer_128\")(x_transformer)\n",
        "    x = Multiply()([Dropout(0.01)(x), x_transformer])\n",
        "    \n",
        "    x = Dense(units=128, activation='selu')(x)\n",
        "    \n",
        "    x_output = Dense(units=1)(x)\n",
        "    \n",
        "    x_output = ScaleLayer()(x_output)\n",
        "\n",
        "    model = Model(inputs=x_input, outputs=x_output, \n",
        "                  name='dnn_TransformerEncoder_model')\n",
        "    return model"
      ],
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_d8ybRJc9co2",
        "outputId": "21e5f5a0-09e1-4ae9-e7af-0840dbbe8969"
      },
      "source": [
        "model = TransformerEncoder_LSTM_model(ff_dim=256,num_heads=8,num_layers=2,)\n",
        "model.summary()"
      ],
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(None, 66)\n",
            "Model: \"DNN_Model\"\n",
            "__________________________________________________________________________________________________\n",
            "Layer (type)                    Output Shape         Param #     Connected to                     \n",
            "==================================================================================================\n",
            "input_2 (InputLayer)            [(None, 80, 66)]     0                                            \n",
            "__________________________________________________________________________________________________\n",
            "time_distributed_1 (TimeDistrib (None, 80, 132)      264         input_2[0][0]                    \n",
            "__________________________________________________________________________________________________\n",
            "tf.concat_1 (TFOpLambda)        (None, 80, 198)      0           input_2[0][0]                    \n",
            "                                                                 time_distributed_1[0][0]         \n",
            "__________________________________________________________________________________________________\n",
            "transformer_encoder_2 (Transfor (None, 80, 198)      916900      tf.concat_1[0][0]                \n",
            "__________________________________________________________________________________________________\n",
            "transformer_encoder_3 (Transfor (None, 80, 198)      916900      transformer_encoder_2[0][0]      \n",
            "__________________________________________________________________________________________________\n",
            "sequential_1 (Sequential)       (None, 80, 128)      2572416     transformer_encoder_3[0][0]      \n",
            "__________________________________________________________________________________________________\n",
            "dense_3 (Dense)                 (None, 80, 1)        129         sequential_1[0][0]               \n",
            "__________________________________________________________________________________________________\n",
            "scale_layer_1 (ScaleLayer)      (None, 80, 1)        0           dense_3[0][0]                    \n",
            "==================================================================================================\n",
            "Total params: 4,406,609\n",
            "Trainable params: 4,406,609\n",
            "Non-trainable params: 0\n",
            "__________________________________________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 865
        },
        "id": "CJtk8i_HSlnc",
        "outputId": "c5eeb81a-cf09-4f36-ab13-e2859e672ace"
      },
      "source": [
        "plot_model(\n",
        "    model, \n",
        "    to_file='Google_Brain_Keras_Model.png', \n",
        "    show_shapes=True,\n",
        "    show_layer_names=True\n",
        ")"
      ],
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {},
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rxWQVBYm-0VK",
        "outputId": "33837110-44a1-4ce1-8adf-99f92b4db29e"
      },
      "source": [
        "del model\n",
        "gc.collect()"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "18278"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u1v9SMji9co3"
      },
      "source": [
        "#reset Keras Session\n",
        "def reset_keras():\n",
        "    sess = tf.compat.v1.keras.backend.get_session()\n",
        "    tf.compat.v1.keras.backend.clear_session()\n",
        "    sess.close()\n",
        "    sess = tf.compat.v1.keras.backend.get_session()\n",
        "\n",
        "    # use the same config as you used to create the session\n",
        "    config = tf.compat.v1.ConfigProto()\n",
        "    config.gpu_options.per_process_gpu_memory_fraction = 1\n",
        "    config.gpu_options.visible_device_list = \"0\"\n",
        "    tf.compat.v1.keras.backend.set_session(tf.compat.v1.Session(config=config))\n",
        "    gc.collect()\n",
        "\n",
        "reset_keras()"
      ],
      "execution_count": 29,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q5bA7_YiN-P9"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "%matplotlib inline\n",
        "import seaborn as sns\n",
        "\n",
        "def press_diff(series: np.ndarray):\n",
        "  return series.diff().abs()\n",
        "\n",
        "\n",
        "def analy_predict(last_test_idx, train_pred):\n",
        "  train_df = pd.read_csv('../input/ventilator-pressure-prediction/train.csv')\n",
        "  last_test_breath_ids = train_df['breath_id'].values.reshape(-1, 80)\n",
        "  last_test_breath_ids = last_test_breath_ids[:, 0]\n",
        "  last_test_breath_ids = last_test_breath_ids.flatten()\n",
        "  last_test_breath_ids = last_test_breath_ids[last_test_idx]\n",
        "\n",
        "  train_pred = train_pred[last_test_idx]\n",
        "  train_pred = train_pred.flatten()\n",
        "\n",
        "  train_df = train_df[train_df['breath_id'].isin(last_test_breath_ids)]\n",
        "  train_df['pred'] = train_pred\n",
        "  train_df['abs_error'] = np.abs(train_pred-train_df['pressure'])\n",
        "  train_df['RC'] = train_df[\"R\"].astype(str) + '__' + train_df[\"C\"].astype(str)\n",
        "  train_df['press_diff'] = train_df.groupby('breath_id')['pressure'].apply(press_diff)\n",
        "\n",
        "  df_feature = train_df[train_df['u_out']<1].groupby('breath_id').agg({'abs_error': ['mean' , 'max', 'min', 'sum', 'count'], \n",
        "                                                                      'RC': ['first'], \n",
        "                                                                      'press_diff':['mean', 'max'],\n",
        "                                                                      'u_in':['first', 'last'],\n",
        "                                                                      'pressure':['first', 'last', 'mean', 'std']\n",
        "                                                                      })\n",
        "  df_feature.columns = ['_'.join(col) for col in df_feature.columns]\n",
        "\n",
        "  plt.figure(figsize=(16,16))\n",
        "\n",
        "  plt.title(\"abs_error distribution by RC\")\n",
        "\n",
        "  for key, grp in df_feature.groupby(['RC_first']):\n",
        "    print(f'{key} - MAE  {grp.abs_error_mean.mean()}, count: {grp.abs_error_count.sum()}')\n",
        "    sns.kdeplot(grp['abs_error_mean'], clip=(0.0, 1), \n",
        "                label=key)\n",
        "\n",
        "  plt.axvline(df_feature['abs_error_mean'].mean())\n",
        "  plt.legend()\n",
        "  plt.show()\n",
        "\n"
      ],
      "execution_count": 30,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N1G5ttKepai8"
      },
      "source": [
        "with tpu_strategy.scope():\n",
        "    skip_folds = np.arange(1)\n",
        "    VERBOSE = 2\n",
        "    EPOCHS = 200\n",
        "    FOLDS = 7\n",
        "    if DEBUG:\n",
        "      EPOCHS = 100\n",
        "    test_preds = []\n",
        "    kf = KFold(n_splits=FOLDS, shuffle=True, random_state=2021)\n",
        "    last_test_idx = []\n",
        "    \n",
        "    for fold, (train_idx, test_idx) in enumerate(kf.split(train, targets)):\n",
        "        last_test_idx = test_idx\n",
        "        if len(test_preds) > fold:\n",
        "          print(f'Ignore corrent fold {fold+1} as we already predicted test data')\n",
        "\n",
        "        if DEBUG and fold > 0:\n",
        "          continue\n",
        "        X_train, X_valid = train[train_idx], train[test_idx]\n",
        "        y_train, y_valid = targets[train_idx], targets[test_idx]\n",
        "        \n",
        "        model = dnn_model_GaussianNoise()\n",
        "        model.compile(optimizer=\"adam\", loss=\"mae\")\n",
        "\n",
        "        lr = ReduceLROnPlateau(monitor=\"val_loss\", factor=0.75, \n",
        "                               patience=10, verbose=VERBOSE)\n",
        "        checkpoint_name = f'./model-gpu/Bidirect_LSTM_model_{fold+1}C.h5'\n",
        "        chk_point = ModelCheckpoint(checkpoint_name,\n",
        "                                    monitor='val_loss', verbose=VERBOSE, \n",
        "                                    save_best_only=True, mode='min')\n",
        "\n",
        "        es = EarlyStopping(monitor=\"val_loss\", patience=50,\n",
        "                           verbose=VERBOSE, mode=\"min\",\n",
        "                           restore_best_weights=True)\n",
        "        \n",
        "        if fold not in skip_folds:\n",
        "          model.fit(X_train, y_train, \n",
        "                    validation_data=(X_valid, y_valid), \n",
        "                    epochs=EPOCHS,\n",
        "                    verbose=VERBOSE,\n",
        "                    batch_size=BATCH_SIZE, \n",
        "                    callbacks=[lr, chk_point, es])\n",
        "        else:\n",
        "          print('Load pretrain weight from ', checkpoint_name)\n",
        "          load_locally = tf.saved_model.LoadOptions(experimental_io_device='/job:localhost')\n",
        "          try:\n",
        "            # At loading time, register the custom objects with a `custom_object_scope`:\n",
        "            custom_objects = {\"ScaleLayer\": ScaleLayer}\n",
        "            with tf.keras.utils.custom_object_scope(custom_objects):\n",
        "                model = load_model(checkpoint_name, options=load_locally)\n",
        "          except (OSError):\n",
        "            print('Cannot load pretrain weight from ', checkpoint_name)\n",
        "            break\n",
        "                \n",
        "        y_true = y_valid.squeeze().reshape(-1, 1)\n",
        "        y_pred = model.predict(X_valid, batch_size=BATCH_SIZE).squeeze().reshape(-1, 1)\n",
        "        train_pred[test_idx] = y_pred.reshape(-1, 80)\n",
        "        score = mean_absolute_error(y_true, y_pred)\n",
        "        test_preds.append(model.predict(test, batch_size=BATCH_SIZE).squeeze().reshape(-1, 1).squeeze())\n",
        "\n",
        "        print(f\"Fold-{fold+1} | OOF Score: {score}\")\n",
        "        \n",
        "        del X_train, X_valid, y_train, y_valid, model\n",
        "        reset_keras()\n",
        "        gc.collect()\n",
        "\n",
        "        analy_predict(test_idx, train_pred)\n",
        "        break"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "INtJvC7xfKdV"
      },
      "source": [
        "skip_folds = []#np.arange(1)\n",
        "train_pred = np.zeros(targets.shape)"
      ],
      "execution_count": 51,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OgZKi4Q-2aoC"
      },
      "source": [
        "with tpu_strategy.scope():\n",
        "    \n",
        "    VERBOSE = 2\n",
        "    EPOCHS = 200\n",
        "    FOLDS = 7\n",
        "    if DEBUG:\n",
        "      EPOCHS = 100\n",
        "    test_preds = []\n",
        "    kf = KFold(n_splits=FOLDS, shuffle=True, random_state=2021)\n",
        "    last_test_idx = []\n",
        "    \n",
        "    for fold, (train_idx, test_idx) in enumerate(kf.split(train, targets)):\n",
        "        last_test_idx = test_idx\n",
        "        if len(test_preds) > fold:\n",
        "          print(f'Ignore corrent fold {fold+1} as we already predicted test data')\n",
        "\n",
        "        if DEBUG and fold > 0:\n",
        "          continue\n",
        "        X_train, X_valid = train[train_idx], train[test_idx]\n",
        "        y_train, y_valid = targets[train_idx], targets[test_idx]\n",
        "        \n",
        "        model = dnn_model_aen()\n",
        "        model.compile(optimizer = tf.keras.optimizers.Adam(learning_rate = 1e-3), \n",
        "              # loss=\"mae\"\n",
        "              loss = {\n",
        "                  'decoder': tf.keras.losses.MeanSquaredError(), \n",
        "                  #'decoder': tf.keras.losses.MeanAbsoluteError(), \n",
        "                  'ae_action': tf.keras.losses.MeanAbsoluteError(),\n",
        "                  'output': tf.keras.losses.MeanAbsoluteError(), \n",
        "                  },\n",
        "              loss_weights = [1, 1, 1]\n",
        "              )\n",
        "\n",
        "        lr = ReduceLROnPlateau(monitor=\"val_output_loss\", factor=0.75, \n",
        "                               patience=10, verbose=VERBOSE)\n",
        "        checkpoint_name = f'./model-gpu/Bidirect_LSTM_model_{fold+1}C.h5'\n",
        "        chk_point = ModelCheckpoint(checkpoint_name,\n",
        "                                    monitor='val_output_loss', \n",
        "                                    verbose=VERBOSE, \n",
        "                                    save_best_only=True, mode='min')\n",
        "\n",
        "        es = EarlyStopping(monitor=\"val_output_loss\", patience=50,\n",
        "                           verbose=VERBOSE, mode=\"min\",\n",
        "                           restore_best_weights=True)\n",
        "        \n",
        "        if fold not in skip_folds:\n",
        "          model.fit(X_train, [X_train, y_train, y_train], \n",
        "                    validation_data=(X_valid, [X_valid, y_valid, y_valid]), \n",
        "                    epochs=EPOCHS,\n",
        "                    verbose=VERBOSE,\n",
        "                    batch_size=BATCH_SIZE, \n",
        "                    callbacks=[lr, chk_point, es])\n",
        "        else:\n",
        "          print('Load pretrain weight from ', checkpoint_name)\n",
        "          load_locally = tf.saved_model.LoadOptions(experimental_io_device='/job:localhost')\n",
        "          try:\n",
        "            # At loading time, register the custom objects with a `custom_object_scope`:\n",
        "            custom_objects = {\"ScaleLayer\": ScaleLayer}\n",
        "            with tf.keras.utils.custom_object_scope(custom_objects):\n",
        "                model = load_model(checkpoint_name, options=load_locally)\n",
        "          except (OSError):\n",
        "            print('Cannot load pretrain weight from ', checkpoint_name)\n",
        "            break\n",
        "                \n",
        "        y_true = y_valid.squeeze().reshape(-1, 1)\n",
        "        y_pred = model.predict(X_valid, batch_size=BATCH_SIZE)[-1].squeeze().reshape(-1, 1)\n",
        "        train_pred[test_idx] = y_pred.reshape(-1, 80)\n",
        "        score = mean_absolute_error(y_true, y_pred)\n",
        "        test_preds.append(model.predict(test, batch_size=BATCH_SIZE)[-1].squeeze().reshape(-1, 1).squeeze())\n",
        "\n",
        "        print(f\"Fold-{fold+1} | OOF Score: {score}\")\n",
        "        \n",
        "        del X_train, X_valid, y_train, y_valid, model\n",
        "        reset_keras()\n",
        "        gc.collect()\n",
        "\n",
        "        analy_predict(test_idx, train_pred)\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lOju5NCSivUg",
        "outputId": "8b945d24-90ce-4c42-cb20-c62cec17c378"
      },
      "source": [
        "train.shape, targets.shape"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "((75450, 80, 66), (75450, 80))"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lYPmE2GVeNCk"
      },
      "source": [
        "# Filter only RC==5050 or 5020\n",
        "retrain_idx = np.logical_or((train[:, 0, -4] == 1), (train[:, 0, -5] == 1))\n",
        "train = train[retrain_idx]\n",
        "targets = targets[retrain_idx]\n",
        "train.shape, targets.shape"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Lx4IqaDowlN2"
      },
      "source": [
        "def RC_loss(y_true, y_pred, weight=50, cols = 80):\n",
        "    rc = y_true[:, cols: ]\n",
        "    y = y_true[:, :cols ]\n",
        "\n",
        "    w = 1 + rc*50\n",
        "    mae = w * tf.abs(y - y_pred)\n",
        "    return tf.reduce_sum(mae, axis=-1) / 80"
      ],
      "execution_count": 33,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6Px5fe-WszKu"
      },
      "source": [
        "#Sometime TF creats model with same weight name and it causes failure of save.\n",
        "def resolve_weight_names(model):\n",
        "  for i in range(len(model.weights)):\n",
        "    print(i, model.weights[i].name)\n",
        "    # model.weights[i]._handle_name = model.weights[i].name + \"_\" + str(i)"
      ],
      "execution_count": 56,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SYJkCi1-9co3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ec55f0d1-4f55-431f-f19d-ccbf4f61b14c"
      },
      "source": [
        "BATCH_SIZE=512\n",
        "IS_WAVENET=False\n",
        "USE_RC_LOSS=False\n",
        "\n",
        "with tpu_strategy.scope():\n",
        "    \n",
        "    VERBOSE = 2\n",
        "    EPOCHS = 300\n",
        "    FOLDS = 7\n",
        "    if DEBUG:\n",
        "      EPOCHS = 100\n",
        "    test_preds = []\n",
        "    kf = KFold(n_splits=FOLDS, shuffle=True, random_state=2021)\n",
        "    last_test_idx = []\n",
        "    \n",
        "    for fold, (train_idx, test_idx) in enumerate(kf.split(train, targets)):\n",
        "        last_test_idx = test_idx\n",
        "        if len(test_preds) > fold:\n",
        "          print(f'Ignore corrent fold {fold+1} as we already predicted test data')\n",
        "\n",
        "        if DEBUG and fold > 0:\n",
        "          continue\n",
        "\n",
        "        X_train, X_valid = train[train_idx], train[test_idx]\n",
        "        y_train, y_valid = targets[train_idx], targets[test_idx]\n",
        "        #Align data to batch size and drop remainder. We only need it for TPU not GPU\n",
        "        if IS_TPU and IS_WAVENET:\n",
        "          fit_batch_size = X_train.shape[0] - (X_train.shape[0]%BATCH_SIZE)\n",
        "          print(X_train.shape[0], fit_batch_size)\n",
        "          X_train, y_train = X_train[:fit_batch_size, :, :], y_train[:fit_batch_size, :]\n",
        "          \n",
        "          fit_batch_size = X_valid.shape[0] - (X_valid.shape[0]%BATCH_SIZE)\n",
        "          print(X_valid.shape[0], fit_batch_size)\n",
        "          X_valid, y_valid = X_valid[:fit_batch_size, :, :], y_valid[:fit_batch_size, :]\n",
        "        \n",
        "        \n",
        "        # model = load_dnn_model_v4_add_wavenet(-3, True)\n",
        "        # model = lstm_wavenet_model()\n",
        "        # model = dnn_TransformerEncoder_model()\n",
        "        model = TransformerEncoder_LSTM_model(ff_dim=256,num_heads=8,num_layers=2,)\n",
        "        resolve_weight_names(model)\n",
        "        model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate = 1e-3),\n",
        "                      # loss=RC_loss\n",
        "                      loss=tf.keras.losses.MeanAbsoluteError()\n",
        "                      )\n",
        "        \n",
        "        \n",
        "\n",
        "        lr = ReduceLROnPlateau(monitor=\"val_loss\", factor=0.75, \n",
        "                               patience=10, verbose=VERBOSE)\n",
        "        \n",
        "        # scheduler = tf.keras.optimizers.schedules.ExponentialDecay(1e-3, 5, 0.9)\n",
        "        # lr = tf.keras.callbacks.LearningRateScheduler(scheduler)\n",
        "\n",
        "        checkpoint_name = f'./model-gpu/transform_encoder_lstm_gpu_{fold+1}C.h5'\n",
        "        chk_point = ModelCheckpoint(checkpoint_name,\n",
        "                                    monitor='val_loss', verbose=VERBOSE, \n",
        "                                    save_best_only=True, mode='min')\n",
        "\n",
        "        es = EarlyStopping(monitor=\"val_loss\", patience=50,\n",
        "                           verbose=VERBOSE, mode=\"min\",\n",
        "                           restore_best_weights=True)\n",
        "        \n",
        "        if fold not in skip_folds:\n",
        "          if USE_RC_LOSS:\n",
        "            model.fit(X_train, np.append(y_train, X_train[:, :, -4]+X_train[:, :, -5], axis =1), \n",
        "                      validation_data=(X_valid, np.append(y_valid, X_valid[:, :, -4]+X_valid[:, :, -5], axis =1)), \n",
        "                      epochs=EPOCHS,\n",
        "                      verbose=VERBOSE,\n",
        "                      batch_size=BATCH_SIZE, \n",
        "                      callbacks=[lr, chk_point, es])\n",
        "          else:\n",
        "            model.fit(X_train, y_train, \n",
        "                      validation_data=(X_valid, y_valid), \n",
        "                      epochs=EPOCHS,\n",
        "                      verbose=VERBOSE,\n",
        "                      batch_size=BATCH_SIZE, \n",
        "                      callbacks=[lr, chk_point, es])\n",
        "        else:\n",
        "          print('Load pretrain weight from ', checkpoint_name)\n",
        "          load_locally = tf.saved_model.LoadOptions(experimental_io_device='/job:localhost')\n",
        "          try:\n",
        "            # At loading time, register the custom objects with a `custom_object_scope`:\n",
        "            custom_objects = {\"ScaleLayer\": ScaleLayer, \"RC_loss\": RC_loss, \n",
        "                              \"Time2Vec\": Time2Vec, \n",
        "                              \"TransformerEncoder\": TransformerEncoder}\n",
        "            with tf.keras.utils.custom_object_scope(custom_objects):\n",
        "                model = load_model(checkpoint_name, options=load_locally)\n",
        "          except (OSError):\n",
        "            print('Cannot load pretrain weight from ', checkpoint_name)\n",
        "            break\n",
        "                \n",
        "        y_true = y_valid.squeeze().reshape(-1, 1)\n",
        "        y_pred = model.predict(X_valid, batch_size=BATCH_SIZE).squeeze().reshape(-1, 1)\n",
        "        score = mean_absolute_error(y_true, y_pred)\n",
        "        print(f\"Fold-{fold+1} | OOF Score: {score}\")\n",
        "\n",
        "        #Save CV predict\n",
        "        if not (IS_TPU and IS_WAVENET):\n",
        "          train_pred[test_idx] = y_pred.reshape(-1, 80)\n",
        "          test_preds.append(model.predict(test, batch_size=1).squeeze().reshape(-1, 1).squeeze())\n",
        "\n",
        "        \n",
        "        del X_train, X_valid, y_train, y_valid, model\n",
        "        reset_keras()\n",
        "        gc.collect()\n",
        "\n",
        "        if not (IS_TPU and IS_WAVENET):\n",
        "          analy_predict(test_idx, train_pred)\n",
        "        "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0 time_distributed_6/wb:0\n",
            "1 time_distributed_6/bb:0\n",
            "2 time_distributed_6/wa:0\n",
            "3 time_distributed_6/ba:0\n",
            "4 transformer_encoder_12/multi_head_attention_14/query/kernel:0\n",
            "5 transformer_encoder_12/multi_head_attention_14/query/bias:0\n",
            "6 transformer_encoder_12/multi_head_attention_14/key/kernel:0\n",
            "7 transformer_encoder_12/multi_head_attention_14/key/bias:0\n",
            "8 transformer_encoder_12/multi_head_attention_14/value/kernel:0\n",
            "9 transformer_encoder_12/multi_head_attention_14/value/bias:0\n",
            "10 transformer_encoder_12/multi_head_attention_14/attention_output/kernel:0\n",
            "11 transformer_encoder_12/multi_head_attention_14/attention_output/bias:0\n",
            "12 transformer_encoder_12/layer_normalization_28/gamma:0\n",
            "13 transformer_encoder_12/layer_normalization_28/beta:0\n",
            "14 transformer_encoder_12/ff_conv1/kernel:0\n",
            "15 transformer_encoder_12/ff_conv1/bias:0\n",
            "16 transformer_encoder_12/layer_normalization_29/gamma:0\n",
            "17 transformer_encoder_12/layer_normalization_29/beta:0\n",
            "18 transformer_encoder_12/ff_conv2/kernel:0\n",
            "19 transformer_encoder_12/ff_conv2/bias:0\n",
            "20 transformer_encoder_13/multi_head_attention_15/query/kernel:0\n",
            "21 transformer_encoder_13/multi_head_attention_15/query/bias:0\n",
            "22 transformer_encoder_13/multi_head_attention_15/key/kernel:0\n",
            "23 transformer_encoder_13/multi_head_attention_15/key/bias:0\n",
            "24 transformer_encoder_13/multi_head_attention_15/value/kernel:0\n",
            "25 transformer_encoder_13/multi_head_attention_15/value/bias:0\n",
            "26 transformer_encoder_13/multi_head_attention_15/attention_output/kernel:0\n",
            "27 transformer_encoder_13/multi_head_attention_15/attention_output/bias:0\n",
            "28 transformer_encoder_13/layer_normalization_30/gamma:0\n",
            "29 transformer_encoder_13/layer_normalization_30/beta:0\n",
            "30 transformer_encoder_13/ff_conv1/kernel:0\n",
            "31 transformer_encoder_13/ff_conv1/bias:0\n",
            "32 transformer_encoder_13/layer_normalization_31/gamma:0\n",
            "33 transformer_encoder_13/layer_normalization_31/beta:0\n",
            "34 transformer_encoder_13/ff_conv2/kernel:0\n",
            "35 transformer_encoder_13/ff_conv2/bias:0\n",
            "36 bidirectional_12/forward_lstm_12/lstm_cell_43/kernel:0\n",
            "37 bidirectional_12/forward_lstm_12/lstm_cell_43/recurrent_kernel:0\n",
            "38 bidirectional_12/forward_lstm_12/lstm_cell_43/bias:0\n",
            "39 bidirectional_12/backward_lstm_12/lstm_cell_44/kernel:0\n",
            "40 bidirectional_12/backward_lstm_12/lstm_cell_44/recurrent_kernel:0\n",
            "41 bidirectional_12/backward_lstm_12/lstm_cell_44/bias:0\n",
            "42 bidirectional_13/forward_lstm_13/lstm_cell_46/kernel:0\n",
            "43 bidirectional_13/forward_lstm_13/lstm_cell_46/recurrent_kernel:0\n",
            "44 bidirectional_13/forward_lstm_13/lstm_cell_46/bias:0\n",
            "45 bidirectional_13/backward_lstm_13/lstm_cell_47/kernel:0\n",
            "46 bidirectional_13/backward_lstm_13/lstm_cell_47/recurrent_kernel:0\n",
            "47 bidirectional_13/backward_lstm_13/lstm_cell_47/bias:0\n",
            "48 dense_11/kernel:0\n",
            "49 dense_11/bias:0\n",
            "50 dense_12/kernel:0\n",
            "51 dense_12/bias:0\n",
            "Epoch 1/300\n",
            "127/127 - 57s - loss: 1.5463 - val_loss: 0.7659\n",
            "\n",
            "Epoch 00001: val_loss improved from inf to 0.76592, saving model to ./model-gpu/transform_encoder_lstm_gpu_1C.h5\n",
            "Epoch 2/300\n",
            "127/127 - 13s - loss: 0.6633 - val_loss: 0.5500\n",
            "\n",
            "Epoch 00002: val_loss improved from 0.76592 to 0.54997, saving model to ./model-gpu/transform_encoder_lstm_gpu_1C.h5\n",
            "Epoch 3/300\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fUanGPDq9co3"
      },
      "source": [
        "if not DEBUG:\n",
        "  train_pred = train_pred.flatten()\n",
        "  targets = targets.flatten()\n",
        "  score = mean_absolute_error(targets, train_pred)\n",
        "  print(f\"Train Score: {score}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QHx2oF849co4"
      },
      "source": [
        "## Create submission file"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tS9VjV7K9co4"
      },
      "source": [
        "if not DEBUG:\n",
        "  submission = pd.read_csv('../input/ventilator-pressure-prediction/sample_submission.csv')\n",
        "  submission[\"pressure\"] = sum(test_preds)/5\n",
        "  submission.to_csv('submission.csv', index=False)\n",
        "\n",
        "  # ENSEMBLE FOLDS WITH MEDIAN\n",
        "  #取中位数\n",
        "  submission[\"pressure\"] = np.median(np.vstack(test_preds),axis=0)\n",
        "  submission.to_csv('submission_median.csv', index=False)\n",
        "\n",
        "\n",
        "  # ENSEMBLE FOLDS WITH MEDIAN AND ROUND PREDICTIONS\n",
        "  submission[\"pressure\"] =\\\n",
        "      np.round( (submission.pressure - pressure_min)/pressure_step ) * pressure_step + pressure_min\n",
        "  submission.pressure = np.clip(submission.pressure, pressure_min, pressure_max)\n",
        "  submission.to_csv('submission_median_round.csv', index=False)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_NUXlVX70A_M"
      },
      "source": [
        "# Analyze predict data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G7JStDQyQ5EJ"
      },
      "source": [
        "#analy_predict(last_test_idx, train_pred)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9TsMS3kv3xZM"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}