enc_dec_with_attention_ppwp_isolation.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.4"
    },
    "colab": {
      "name": "enc_dec_with_attention_ppwp_isolation.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/eorland/LSTM-Multistep-Prediction/blob/master/enc_dec_with_attention_ppwp_isolation.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-01-22T22:44:13.832760Z",
          "start_time": "2020-01-22T22:44:13.722630Z"
        },
        "id": "8B-ONIu6hxWH",
        "colab_type": "code",
        "outputId": "9b15cfc3-2e4c-4583-8547-df1af677b127",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        }
      },
      "source": [
        "#everything we will import to use later\n",
        "import os\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "from matplotlib import pyplot as plt\n",
        "from tensorflow.keras.models import model_from_json\n",
        "%matplotlib inline\n",
        "\n",
        "import tensorflow.compat.v1 as tf\n",
        "from tensorflow.keras import backend as K\n",
        "from tensorflow.keras import Model\n",
        "from tensorflow.keras.layers import *\n",
        "from tensorflow.keras.wrappers.scikit_learn import KerasRegressor\n",
        "from sklearn import preprocessing\n",
        "from sklearn.metrics import mean_squared_error\n",
        "#check our version\n",
        "print(tf.VERSION)\n",
        "print(tf.keras.__version__)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2.2.0-rc4\n",
            "2.3.0-tf\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Em6RMwSKigzV",
        "colab_type": "code",
        "outputId": "1f6b5b63-3ac2-43c5-a994-eb5674c66188",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "device_name = tf.test.gpu_device_name()\n",
        "if device_name != '/device:GPU:0':\n",
        "  raise SystemError('GPU device not found')\n",
        "print('Found GPU at: {}'.format(device_name))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Found GPU at: /device:GPU:0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-01-22T22:44:14.097519Z",
          "start_time": "2020-01-22T22:44:14.051319Z"
        },
        "id": "VUuCin7PhxWY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def rescale(feature_data,test_targets,predictions, scaling_object,index):\n",
        "    '''Flattens and rescales test and prediction data back to the original scale.\n",
        "    Given that the test data and predictions do not have the same shape as the original feature data, we need \n",
        "    to \"pad\" these two datasets with the original column numbers of the feature data, \n",
        "    as well as have the test and prediction data occupy the same positions of their respective \n",
        "    target data columns so the rescale is done properly. \n",
        "    The below code includes one way to correctly do this padding.\n",
        "    \n",
        "    INPUTS: training or test feature data (it doesn't matter--we just need the same number of columns)\n",
        "    test targets, and predictions, all in 3D tensor form. Also, the scaling object used \n",
        "    for the original transformation'''\n",
        "    \n",
        "    #flatten predictions and test data\n",
        "    predict_flat = predictions.reshape(predictions.shape[0]*predictions.shape[1],predictions.shape[2])\n",
        "    y_test_flat = test_targets.reshape(test_targets.shape[0]*test_targets.shape[1],test_targets.shape[2])\n",
        "\n",
        "    #flatten the features dataframe. This has the dimensions we want.\n",
        "    flattened_features = pd.DataFrame(feature_data.reshape(feature_data.shape[0]*feature_data.shape[1],\n",
        "                                                           feature_data.shape[2]))\n",
        "    \n",
        "    #if we want to predict long sequences these will likely be longer than the length of the features.\n",
        "    #we just add some zeros here to pad out the feature length to match. We'll then convert these to NaN's\n",
        "    #so they're ignored. Again, we just want to inherient the 7 col \n",
        "    #structure of the feature data--not the values. This is the most foolproof method\n",
        "    #I've found through trial and error.\n",
        "    \n",
        "    if len(flattened_features) < len(y_test_flat):\n",
        "        print('Length of targets exceeds length of features. Now padding...\\n')\n",
        "        extra_rows = pd.DataFrame(np.zeros((len(y_test_flat),flattened_features.shape[1])))\n",
        "        flattened_features = pd.concat([flattened_features,extra_rows],axis=0)\n",
        "        flattened_features[flattened_features==0]=np.nan\n",
        "        \n",
        "    #make a start column, this is the index where we begin to repopulate the target cols with the \n",
        "    #data we want to rescale\n",
        "    start_col = feature_data.shape[2]-test_targets.shape[2]\n",
        "    total_col = feature_data.shape[2]\n",
        "    \n",
        "    #make trimmed feature copies of equal length as the test data and predictions lengths, \n",
        "    #and leave out the original target data... we will replace these cols with the test and prediction data\n",
        "    flattened_features_test_copy = flattened_features.iloc[:len(y_test_flat),:start_col]\n",
        "    flattened_features_pred_copy = flattened_features.iloc[:len(y_test_flat),:start_col]\n",
        "    #print((flattened_features_pred_copy.values))\n",
        "    \n",
        "    for i in range(start_col,total_col):\n",
        "        #reassign targets cols\n",
        "        flattened_features_test_copy[i] = y_test_flat[:,i-start_col] \n",
        "        flattened_features_pred_copy[i] = predict_flat[:,i-start_col]\n",
        "        #by specifying 'i - start col', we are making sure the target column being \n",
        "        #repopulated is the matching target taken from the test data or predictions.\n",
        "        #Ex: if the start col is 4, then we want to assign the first column of the test and pred data--\n",
        "        #this is index 0, and 4-4 = 0.\n",
        "        \n",
        "    #We now have the correct dimensions, so we can FINALLY rescale\n",
        "    y_test_rescale = scaling_object.inverse_transform(flattened_features_test_copy)\n",
        "    preds_rescale = scaling_object.inverse_transform(flattened_features_pred_copy)\n",
        "    \n",
        "    #just grab the target cols.\n",
        "    y_test_rescale = y_test_rescale[:,start_col:]\n",
        "    preds_rescale = preds_rescale[:,start_col:]\n",
        "    \n",
        "    preds_rescale = pd.DataFrame(preds_rescale,index=index)\n",
        "    y_test_rescale = pd.DataFrame(y_test_rescale,index=index)\n",
        "    \n",
        "    \n",
        "     #before we return the dataframes, check and see if predictions or test data have null values.\n",
        "    if preds_rescale.isnull().values.any()==True:\n",
        "        print('Keras predictions have NaN values present. Deleting...')\n",
        "        print('Current shape: ' + str(preds_rescale.shape))\n",
        "        nans = np.argwhere(np.isnan(preds_rescale.values)) #find nulls\n",
        "        #delete make sure values are deleted from both\n",
        "        y_test_rescale = np.delete(y_test_rescale.values, nans,axis=0)\n",
        "        preds_rescale = np.delete(preds_rescale.values, nans, axis=0)\n",
        "        index = np.delete(index, nans, axis=0)\n",
        "        #turn back into dataframe in case next condition is also true\n",
        "        preds_rescale = pd.DataFrame(preds_rescale, index=index) \n",
        "        y_test_rescale = pd.DataFrame(y_test_rescale, index=index)\n",
        "        print('New Shape: ' + str(preds_rescale.shape))\n",
        "        \n",
        "    \n",
        "    if y_test_rescale.isnull().values.any()==True:\n",
        "        print('Test data still have NaN values present. Deleting...')\n",
        "        print('Current shape: ' + str(y_test_rescale.shape))\n",
        "        nans = np.argwhere(np.isnan(y_test_rescale.values)) \n",
        "        #same as above\n",
        "        y_test_rescale = np.delete(y_test_rescale.values, nans,axis=0)\n",
        "        preds_rescale = np.delete(preds_rescale.values, nans, axis=0)\n",
        "        index = np.delete(index, nans, axis=0)\n",
        "        # make into DataFrame this time to guarantee the below return statement won't spit an error\n",
        "        y_test_rescale = pd.DataFrame(y_test_rescale,index=index)\n",
        "        preds_rescale = pd.DataFrame(preds_rescale,index=index)\n",
        "        print('New shape: ' + str(y_test_rescale.shape))\n",
        "    \n",
        "    print('test data new shape: ' + str(y_test_rescale.shape))\n",
        "    print('prediction new shape: ' + str(preds_rescale.shape))\n",
        "    return y_test_rescale,preds_rescale"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-01-22T22:44:14.641423Z",
          "start_time": "2020-01-22T22:44:14.544395Z"
        },
        "id": "QvYLVu14hxWj",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def lstm_prep(data_index,data,ntargets,ninputs,noutputs=1,show_progress=False):\n",
        "    '''Prepares and reshapes data for use with an LSTM. Outputs features, targets,\n",
        "    and the original data indices of your target values for visualization later. Requires that \n",
        "    the targets are the last N columns in your dataset.\n",
        "    \n",
        "    NOTE: The applies a moving window approach at intervals of the output steps, such that \n",
        "    you group the previous timesteps of inputs for your features (whatever length you choose),set the next \n",
        "    X timesteps of target values as outputs (again, whatever you want), and then move the window X (noutputs)\n",
        "    timesteps in the future to repeat the process. Analogous to a cnn kernal with a stride equal to the output length. \n",
        "    I wrote this to automate and quickly change between varying input and output sequence lengths, \n",
        "    but wanted to avoid overlapping values typical in a moving window approach. \n",
        "    Having these non-overlapping values just makes plotting easier. \n",
        "    So far I have yet to see a need for more samples, which I understand is why the \n",
        "    moving window approach is typicallyimplemented.'''\n",
        "    \n",
        "    target_data = data[:,-ntargets:]\n",
        "    features = np.empty((ninputs,data.shape[1]), int)\n",
        "    targets = np.empty((noutputs,ntargets),int)\n",
        "    for i in range(ninputs,(len(data)-noutputs),noutputs): \n",
        "        if show_progress==True:\n",
        "            print('current index: '+str(i))\n",
        "            print('feature indices: '+str(i-ninputs)+' to '+str(i-1))\n",
        "            print('target indices: '+str(i)+' to '+str(i+noutputs-1))\n",
        "        #print(i)\n",
        "        temp_feature_matrix = data[(i-ninputs):i]\n",
        "        temp_target_matrix = target_data[(i):(i+noutputs)]\n",
        "        #print(i+noutputs)\n",
        "        features = np.vstack((features, temp_feature_matrix))\n",
        "        targets = np.vstack((targets,temp_target_matrix))\n",
        "    \n",
        "    last_index = i+noutputs\n",
        "    features = features.reshape((int(features.shape[0]/ninputs),ninputs,features.shape[1]))\n",
        "    targets = targets.reshape(int(targets.shape[0]/noutputs),noutputs,targets.shape[1])\n",
        "    \n",
        "    target_indices = data_index[ninputs:last_index]\n",
        "    \n",
        "    return features[1:], targets[1:], target_indices\n",
        "\n",
        "def rectify_cnn_data(predictions, targets, num_targets, noutputs):\n",
        "    preds = np.empty((noutputs,num_targets), int)\n",
        "    tests = np.empty((noutputs,num_targets), int)\n",
        "    for row in range(0,predictions.shape[0]):\n",
        "        pred_t = np.transpose(np.array(np.split(predictions[row],num_targets)))\n",
        "        #print('preds: '+ str(pred_t))\n",
        "        preds = np.vstack((preds, pred_t))\n",
        "\n",
        "        test_t = np.transpose(np.array(np.split(targets[row],num_targets)))\n",
        "        #print('tests: '+ str(test_t))\n",
        "        tests = np.vstack((tests, test_t))\n",
        "    #print(preds)\n",
        "    return preds[noutputs:], tests[noutputs:]\n",
        "\n",
        "\n",
        "def mse_nan(y_true, y_pred):\n",
        "    masked_true = tf.where(tf.is_nan(y_true), tf.zeros_like(y_true), y_true)\n",
        "    masked_pred = tf.where(tf.is_nan(y_true), tf.zeros_like(y_true), y_pred)\n",
        "    return K.mean(K.square(masked_pred - masked_true), axis=-1)\n",
        "\n",
        "def mae_nan(y_true, y_pred):\n",
        "    masked_true = tf.where(tf.is_nan(y_true), tf.zeros_like(y_true), y_true)\n",
        "    masked_pred = tf.where(tf.is_nan(y_true), tf.zeros_like(y_true), y_pred)\n",
        "    return K.mean(abs(masked_pred - masked_true), axis=-1)\n",
        "\n",
        "\n",
        "def evaluate_forecasts(actual, predicted): #from Jason Brownlee's blog\n",
        "    scores = list()\n",
        "    # calculate an RMSE score for each day\n",
        "    for i in range(actual.shape[1]):\n",
        "        # calculate mse\n",
        "        mse = mean_squared_error(actual[:, i], predicted[:, i])\n",
        "        #print('mse: '+ str(mse))\n",
        "        # calculate rmse\n",
        "        rmse = np.sqrt(mse)\n",
        "        # store\n",
        "        scores.append(rmse)\n",
        "    # calculate overall RMSE\n",
        "    s = 0\n",
        "    for row in range(actual.shape[0]):\n",
        "        for col in range(actual.shape[1]):\n",
        "            s += (actual[row, col] - predicted[row, col])**2\n",
        "    score = np.sqrt(s / (actual.shape[0] * actual.shape[1]))\n",
        "    \n",
        "    print(scores)\n",
        "    return score, scores\n",
        "\n",
        "def threshold_rmse_eval(tests, preds, threshold):\n",
        "    pred_pos_all = []\n",
        "    y_pos_all = []\n",
        "    rmse = []\n",
        "    for i in range(preds.shape[1]):\n",
        "        #grab individual cols\n",
        "        data_slice_test = tests[:,i]\n",
        "        data_slice_pred = preds[:,i]\n",
        "        \n",
        "        if max(data_slice_test) < threshold:\n",
        "          print(\"Threshold too high for column: \"+str(i))\n",
        "          rmse.append('N/A')\n",
        "          y_pos_all.append('N/A')\n",
        "          pred_pos_all.append('N/A')\n",
        "          continue\n",
        "        \n",
        "        #This avoids a warning for the np.where query a couple of lines down...\n",
        "        test_nans = np.where(np.isnan(data_slice_test)) #find nans and replace with dummy value. \n",
        "        tests[test_nans] = threshold*100\n",
        "        \n",
        "        #find all values greater than or equal to your threshold value\n",
        "        pos_test = np.where(data_slice_test >= threshold)\n",
        "        y_pos = data_slice_test[pos_test] #get those values from the test data\n",
        "        pred_pos = data_slice_pred[pos_test] #get the equivalent values from the predictions\n",
        "\n",
        "        #calculate mse, rmse\n",
        "        mse = mean_squared_error(y_pos, pred_pos)\n",
        "        rmse_val = np.sqrt(mse)\n",
        "        \n",
        "        #append all values to our respective lists\n",
        "        rmse.append(rmse_val)\n",
        "        y_pos_all.append(y_pos)\n",
        "        pred_pos_all.append(pred_pos)\n",
        "    \n",
        "    print('per target rmse: ' + str(rmse))\n",
        "    return np.asarray(rmse),np.asarray(y_pos_all),np.asarray(pred_pos_all)\n",
        "    \n",
        "    #make a list of rmse per datapoint\n",
        "    diff_array = np.empty((1,tests.shape[1]),int)\n",
        "    for row in range(tests.shape[0]):\n",
        "        diffs = []\n",
        "        for col in range(tests.shape[1]):\n",
        "            #print(tests[row,col])\n",
        "            #print(preds[row,col])\n",
        "            diff = tests[row,col] - preds[row, col]\n",
        "            diffs.append(diff)\n",
        "        diffs = np.array(diffs)\n",
        "        diff_array = np.vstack((diff_array,diffs))\n",
        "    \n",
        "    return y_pos_all, pred_pos_all, rmse, diff_array[1:]\n",
        "\n",
        "def naive_forecast(test_data,backsteps,forward_steps):\n",
        "    back_array = np.arange(0,backsteps+1)\n",
        "    naive_preds = np.zeros(shape=(test_data.shape[0],test_data.shape[1]))\n",
        "    for row in range(0,test_data.shape[0],forward_steps):\n",
        "        #print(row)\n",
        "        for col in range(test_data.shape[1]):\n",
        "            if row in back_array:\n",
        "                naive_preds[row,col] = test_data[row,col]\n",
        "            else:\n",
        "                naive_preds[row,col] = np.mean(test_data[(row-backsteps):row,col])\n",
        "                for i in range(1,forward_steps):\n",
        "                    row_index = row+i\n",
        "                    if row_index == len(test_data):\n",
        "                        break\n",
        "                    else:\n",
        "                        naive_preds[(row_index),col] = np.mean(naive_preds[(row_index-backsteps):row_index,col])\n",
        "\n",
        "    return naive_preds\n",
        "\n",
        "def add_max_rainfall(data,interval,rain_col,noise=False):\n",
        "    #print(len(data))\n",
        "    '''takes times series data as input, and calculates the maximum and total rainfall values \n",
        "    for a fixed interval, based on the column index of your rainfall (rain_col).\n",
        "\n",
        "    This function assumes you are using pandas, but can be modified for numpy arrays, which will perform faster\n",
        "    for larger datasets'''\n",
        "    rain_total = np.array(np.zeros(len(data)))\n",
        "    rain_max = np.array(np.zeros(len(data)))\n",
        "    \n",
        "    if noise==True:\n",
        "      print('adding with noise')\n",
        "      for row in range(0,len(data),1):\n",
        "        print('no test')\n",
        "        if row >= (len(data) - interval):\n",
        "            rain_total[row] = (np.sum(data.iloc[row:len(data),rain_col]))*np.random.randint(0.75,1.25)\n",
        "            rain_max[row] = (max(data.iloc[row:len(data),rain_col]))*np.random.randint(0.75,1.25)\n",
        "            \n",
        "        rain_total[row] = np.sum(data.iloc[row:row+interval,rain_col])*np.random.randint(0.75,1.25)\n",
        "        rain_max[row] = max(data.iloc[row:row+interval,rain_col])*np.random.randint(0.75,1.25)\n",
        "\n",
        "\n",
        "\n",
        "    else:\n",
        "      #print('adding with no noise')\n",
        "      for row in range(0,len(data),1):\n",
        "          \n",
        "          if row >= (len(data) - interval):\n",
        "              rain_total[row] = np.sum(data.iloc[row:len(data),rain_col])\n",
        "              rain_max[row] = np.nanmax(data.iloc[row:len(data),rain_col])\n",
        "          \n",
        "          rain_total[row] = np.sum(data.iloc[row:row+interval,rain_col])\n",
        "          rain_max[row] = np.nanmax(data.iloc[row:row+interval,rain_col])\n",
        "          #print(np.nanmax(data.iloc[row:row+interval,rain_col]))\n",
        "\n",
        "    data[str(interval)+'hr_total_rfall'] = rain_total\n",
        "    data[str(interval)+'hr_max_rfall'] = rain_max\n",
        "    \n",
        "    return data"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6FQeEeb5iA7T",
        "colab_type": "code",
        "outputId": "57ccf1cd-30b6-46cc-fa78-dca5e7580391",
        "colab": {
          "resources": {
            "http://localhost:8080/nbextensions/google.colab/files.js": {
              "data": "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",
              "ok": true,
              "headers": [
                [
                  "content-type",
                  "application/javascript"
                ]
              ],
              "status": 200,
              "status_text": "OK"
            }
          },
          "base_uri": "https://localhost:8080/",
          "height": 71
        }
      },
      "source": [
        "from google.colab import files\n",
        "uploaded = files.upload()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-ddf6a5de-30cd-4540-8086-3423e335bf85\" name=\"files[]\" multiple disabled />\n",
              "     <output id=\"result-ddf6a5de-30cd-4540-8086-3423e335bf85\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script src=\"/nbextensions/google.colab/files.js\"></script> "
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Saving SP1.txt to SP1.txt\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-01-22T22:44:23.005938Z",
          "start_time": "2020-01-22T22:44:15.668946Z"
        },
        "id": "QJSqohV0hxWt",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "ocr = pd.read_csv('SP1.txt',index_col='timestamp_utc',sep='\\t')\n",
        "datetime = pd.to_datetime(ocr.index,dayfirst=False)\n",
        "ocr = ocr.set_index(datetime)\n",
        "mask_cols = ['porePressure_63cm_kPa','porePressure_113cm_kPa','porePressure_244cm_kPa']\n",
        "ocr[mask_cols] = ocr[mask_cols].mask(ocr[mask_cols] < -14)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-01-22T22:44:24.254337Z",
          "start_time": "2020-01-22T22:44:24.245279Z"
        },
        "id": "PxkQrrDHhxW3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# set dates also as feature cols\n",
        "ocr['date'] = ocr.index.values.astype(float)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-01-22T22:46:28.112431Z",
          "start_time": "2020-01-22T22:44:24.712653Z"
        },
        "id": "lZD-bkK6hxW-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# add in forecasted rainfall\n",
        "# this will take a while\n",
        "for i in range(2,38,2):\n",
        "  ocr = add_max_rainfall(ocr,i,0,noise=False)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y8wGddL_qDe0",
        "colab_type": "code",
        "outputId": "ac0023ec-c247-4da3-916e-38a842a824c7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 278
        }
      },
      "source": [
        "# look at all cols\n",
        "ocr.columns"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Index(['RG_mm', 'VWC_20cm', 'VWC_50cm', 'VWC_93cm', 'porePressure_63cm_kPa',\n",
              "       'porePressure_113cm_kPa', 'porePressure_244cm_kPa', 'date',\n",
              "       '2hr_total_rfall', '2hr_max_rfall', '4hr_total_rfall', '4hr_max_rfall',\n",
              "       '6hr_total_rfall', '6hr_max_rfall', '8hr_total_rfall', '8hr_max_rfall',\n",
              "       '10hr_total_rfall', '10hr_max_rfall', '12hr_total_rfall',\n",
              "       '12hr_max_rfall', '14hr_total_rfall', '14hr_max_rfall',\n",
              "       '16hr_total_rfall', '16hr_max_rfall', '18hr_total_rfall',\n",
              "       '18hr_max_rfall', '20hr_total_rfall', '20hr_max_rfall',\n",
              "       '22hr_total_rfall', '22hr_max_rfall', '24hr_total_rfall',\n",
              "       '24hr_max_rfall', '26hr_total_rfall', '26hr_max_rfall',\n",
              "       '28hr_total_rfall', '28hr_max_rfall', '30hr_total_rfall',\n",
              "       '30hr_max_rfall', '32hr_total_rfall', '32hr_max_rfall',\n",
              "       '34hr_total_rfall', '34hr_max_rfall', '36hr_total_rfall',\n",
              "       '36hr_max_rfall'],\n",
              "      dtype='object')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-01-22T22:46:39.077801Z",
          "start_time": "2020-01-22T22:46:39.056890Z"
        },
        "id": "Rr8pofRihxXK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# rearrange so we have all the feature cols as we want them\n",
        "ocr = ocr.loc[:,['date', 'RG_mm', '2hr_total_rfall', '2hr_max_rfall', '4hr_total_rfall', '4hr_max_rfall',\n",
        "       '6hr_total_rfall', '6hr_max_rfall', '8hr_total_rfall', '8hr_max_rfall',\n",
        "       '10hr_total_rfall', '10hr_max_rfall', '12hr_total_rfall',\n",
        "       '12hr_max_rfall', '14hr_total_rfall', '14hr_max_rfall',\n",
        "       '16hr_total_rfall', '16hr_max_rfall', '18hr_total_rfall',\n",
        "       '18hr_max_rfall', '20hr_total_rfall', '20hr_max_rfall',\n",
        "       '22hr_total_rfall', '22hr_max_rfall', '24hr_total_rfall',\n",
        "       '24hr_max_rfall', '26hr_total_rfall', '26hr_max_rfall',\n",
        "       '28hr_total_rfall', '28hr_max_rfall', '30hr_total_rfall',\n",
        "       '30hr_max_rfall', '32hr_total_rfall', '32hr_max_rfall',\n",
        "       '34hr_total_rfall', '34hr_max_rfall', '36hr_total_rfall',\n",
        "       '36hr_max_rfall', 'VWC_20cm', 'VWC_50cm', 'VWC_93cm',\n",
        "       'porePressure_63cm_kPa', 'porePressure_113cm_kPa',\n",
        "       'porePressure_244cm_kPa']]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iBsX0iUFe_f8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# create a feature scaling object for use later\n",
        "data = ocr\n",
        "data_scaling = preprocessing.MinMaxScaler(feature_range=(0,1)).fit(data.iloc[:,:])\n",
        "data_scaled = pd.DataFrame(data_scaling.transform(data.iloc[:,:]),index=ocr.index)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s5rjKlIYqLxw",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# now create our features and targets\n",
        "all_features, all_targets, all_target_indices = lstm_prep(\n",
        "    ocr.index.values,ocr.values,3,36,36)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3WwcVVxB2qyf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# set prediction intervals for each batch... this is useful for plotting later\n",
        "intervals = np.zeros(len(all_target_indices))\n",
        "for i in range(0,len(intervals),all_targets.shape[1]):\n",
        "    intervals[i]=1\n",
        "\n",
        "intervals[intervals==0] = np.nan\n",
        "\n",
        "binary_indices = np.copy(all_target_indices)\n",
        "\n",
        "for i in range(0,len(binary_indices),all_targets.shape[1]):\n",
        "    binary_indices[i]=np.datetime64(\"NaT\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RiGTASUQCels",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def isolate_threshold_rainfall(feature_data,target_data,target_indices,rain_col,\n",
        "                               threshold_value):\n",
        "  \n",
        "  '''Sorts feature and target data based on \n",
        "  a user-specificed threshold. It returns 4 lists with \n",
        "  the above and below threshold values, respectively, in order:\n",
        "  feature, target, target indices (features have the index built in),\n",
        "  a list of the max rainfall from each positive batch, and the same for the \n",
        "  negative batches. The last two are just helpful for making the algorithm\n",
        "  correctly sorted based on a fixed threshold, i.e., the negatives only have\n",
        "  max values below the threshold.\n",
        "  \n",
        "  Input \"target_columns\" specifies the number of target features present,\n",
        "  and assumes these are placed as the last members of your feature data'''\n",
        "\n",
        "\n",
        "  # reshape 1D target indices to be in 'batch' form similar to features/targets\n",
        "  # every new row now corresponds to the n timesteps of each batch\n",
        "  target_indices_re = np.reshape(target_indices, (target_data.shape[0],\n",
        "                                                  target_data.shape[1]))\n",
        "  thresh_features = []\n",
        "  thresh_targets = []\n",
        "  arrays_to_delete = []\n",
        "  ppwp_indices = []\n",
        "  pthresh_list = []\n",
        "  nthresh_list = []\n",
        "\n",
        "  for batch in range(0,target_data.shape[0],1):\n",
        "    print('batch: '+str(batch))\n",
        "    target_array = target_data[batch,:,:]\n",
        "    \n",
        "    # create 'feature array' that just has the col of interest\n",
        "    feature_array = feature_data[batch,:,rain_col]\n",
        "\n",
        "    # get all values in the current array over threshold, if any\n",
        "    values_above_thresh = (feature_array[feature_array >= threshold_value])\n",
        "\n",
        "    if len(values_above_thresh) != 0:\n",
        "      print('values above thresh: '+ str(len(values_above_thresh)))\n",
        "      print('max: '+str(np.nanmax(feature_array)))\n",
        "      print('min: ' +str(np.nanmin(feature_array)))\n",
        "      pthresh_list.append(np.nanmax(feature_array))\n",
        "      #print(np.nanmax(feature_array))\n",
        "      #print(len(values_above_thresh))\n",
        "      # if we have positives, add that 'batch' to our new ppwp datasets\n",
        "      thresh_features.append(feature_data[batch,:,:])\n",
        "      thresh_targets.append(target_data[batch,:,:])\n",
        "      arrays_to_delete.append(batch)\n",
        "      ppwp_indices.append(target_indices_re[batch,:])\n",
        "      #print(\"values appended\")\n",
        "\n",
        "    else:\n",
        "      print('none above threshold')\n",
        "      #print('values above thresh: '+ str(len(values_above_thresh)))\n",
        "      nthresh_list.append(np.nanmax(feature_array))\n",
        "      #print('max: ' +str(np.nanmax(feature_array)))\n",
        "      #print('no threshold met')\n",
        "      continue\n",
        "  \n",
        "  # deleting indices no longer in feature/target data\n",
        "  npwp_indices = np.delete(target_indices_re,np.asarray(arrays_to_delete),0)\n",
        "\n",
        "  #reshaping to correct form for use later\n",
        "  npwp_indices_2d = npwp_indices.reshape(\n",
        "      npwp_indices.shape[0]*npwp_indices.shape[1])\n",
        "  \n",
        "  ppwp_indices = (np.asarray(ppwp_indices))\n",
        "\n",
        "  #same reshaping process\n",
        "  ppwp_indices_2d = ppwp_indices.reshape(\n",
        "      ppwp_indices.shape[0]*ppwp_indices.shape[1])\n",
        "  \n",
        "  # delete positive pressures from our dataset\n",
        "  feature_data_no_thresh = np.delete(feature_data, \n",
        "                                     np.asarray(arrays_to_delete),0)\n",
        "  target_data_no_thresh = np.delete(target_data, \n",
        "                                    np.asarray(arrays_to_delete),0)\n",
        "\n",
        "  # group items in list for simplicity\n",
        "  ppwp_items = [np.asarray(thresh_features), np.asarray(thresh_targets), \n",
        "          ppwp_indices_2d]\n",
        "  \n",
        "  npwp_items = [feature_data_no_thresh, target_data_no_thresh,\n",
        "                     npwp_indices_2d]\n",
        "                     \n",
        "\n",
        "  print('pthresh max: '+str(np.nanmax(pthresh_list)))\n",
        "  print('nthresh max: '+str(np.nanmax(nthresh_list)))\n",
        "  return ppwp_items, npwp_items, pthresh_list, nthresh_list"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hKMBT2UZN6p7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# create separate feature and target datasets, based on which target\n",
        "# sequences feature positive pore-water pressures\n",
        "ppwp_items, npwp_items, pthresh, nthresh = isolate_threshold_rainfall(all_features,all_targets,\n",
        "                                                    all_target_indices,-7,4)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aNgUDjgXn8O3",
        "colab_type": "code",
        "outputId": "6756a04b-a5e1-43c7-a8fe-28c0602e3d17",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 334
        }
      },
      "source": [
        "#plot histogram of max below 4mm threshold 36hr forecast... \n",
        "# correctly, there is nothing above the 4mm I specified\n",
        "plt.hist(nthresh)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(array([235.,   8.,  91.,  16.,  10.,  59.,  22.,  69.,   3.,  11.]),\n",
              " array([0.   , 0.381, 0.762, 1.143, 1.524, 1.905, 2.286, 2.667, 3.048,\n",
              "        3.429, 3.81 ]),\n",
              " <a list of 10 Patch objects>)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ukhQy0xEyZjt",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "ppwp_f, ppwp_t, ppwp_ti = ppwp_items\n",
        "npwp_f, npwp_t, npwp_ti = npwp_items"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cj_Dcr6kxklk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# now we temporarily reshape features to 2D arrays, just to rescale\n",
        "ppwp_f_re = np.reshape(ppwp_f,(ppwp_f.shape[0]*ppwp_f.shape[1],ppwp_f.shape[2]))\n",
        "ppwp_f_index = pd.to_datetime(ppwp_f_re[:,0]) # track feature index for convenience\n",
        "\n",
        "#scale\n",
        "ppwp_f_scaled = pd.DataFrame(data_scaling.transform(ppwp_f_re),index=ppwp_f_index)\n",
        "ppwp_f_scaled_fna = ppwp_f_scaled.fillna(-1)\n",
        "\n",
        "\n",
        "# same thing as above for negative pressures\n",
        "npwp_f_re = np.reshape(npwp_f,(npwp_f.shape[0]*npwp_f.shape[1],npwp_f.shape[2]))\n",
        "npwp_f_index = pd.to_datetime(npwp_f_re[:,0]) # feature index for below threshold\n",
        "npwp_f_scaled = pd.DataFrame(data_scaling.transform(npwp_f_re),index=npwp_f_index)\n",
        "npwp_f_scaled_fna = npwp_f_scaled.fillna(-1)\n",
        "\n",
        "# shape back into 3D\n",
        "# yes, this is repetitive\n",
        "ppwp_f_scaled_re = np.reshape(ppwp_f_scaled_fna.values,\n",
        "                              (ppwp_f.shape[0],ppwp_f.shape[1],ppwp_f.shape[2]))\n",
        "\n",
        "npwp_f_scaled_re = np.reshape(npwp_f_scaled_fna.values,\n",
        "                              (npwp_f.shape[0],npwp_f.shape[1],npwp_f.shape[2]))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1zrpDMIX4asz",
        "colab_type": "code",
        "outputId": "1840363c-132c-4952-d1e0-cd313368808c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 304
        }
      },
      "source": [
        "# as final check... let's look at the 36hr_max_rfall \n",
        "# upon which we base our thresholds for all the feature data\n",
        "# notice our trianing data has all forecasts below 4mm.\n",
        "print(np.nanmax(ocr.loc[npwp_f_index,'36hr_max_rfall']))\n",
        "plt.scatter(npwp_f_index,(ocr.loc[npwp_f_index,'36hr_max_rfall']))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3.81\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.collections.PathCollection at 0x7f3b8a30ee80>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-01-22T22:46:56.876575Z",
          "start_time": "2020-01-22T22:46:56.866142Z"
        },
        "id": "TcF5iy_yhxX3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# this is a bit of an arbitrary split\n",
        "# mostly lets just see how well the model performs on below threshold data\n",
        "split = 0.7\n",
        "train_features = npwp_f_scaled_re[:int((len(npwp_f_scaled_re)*split))]\n",
        "test_features = npwp_f_scaled_re[int((len(npwp_f_scaled_re)*split)):]\n",
        "\n",
        "train_targets = npwp_t[:int((len(npwp_f_scaled_re)*split))]\n",
        "test_targets = npwp_t[int((len(npwp_f_scaled_re)*split)):]\n",
        "test_indices = npwp_ti[-test_targets.shape[0]*test_targets.shape[1]:]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5HXXTCQGhxYn",
        "colab_type": "text"
      },
      "source": [
        "Create our Encoder:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-01-22T22:23:22.261323Z",
          "start_time": "2020-01-22T22:23:18.861Z"
        },
        "id": "pMTItD5khxYq",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Define an input shape. This is the tensor shape our model expects from now on.\n",
        "# This is essential for a stateful model\n",
        "batch = None\n",
        "n_units = 36\n",
        "\n",
        "encoder_inputs = Input(batch_input_shape=(batch,train_features.shape[1],train_features.shape[2]))\n",
        "\n",
        "encoder_lstm = LSTM(n_units, return_state=True,stateful=False,return_sequences=True) # define encoder\n",
        "\n",
        "# connect encoding layer to our inputs, return all states\n",
        "encoder_outputs, state_h, state_c = encoder_lstm(encoder_inputs) \n",
        "\n",
        "encoder_states = [state_h, state_c]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6sbuXWxUzVhZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "encoder_lstm = Bidirectional(LSTM(units=n_units, return_sequences=True, return_state=True)) # Bidirectional\n",
        "encoder_outputs, fstate_h, fstate_c, bstate_h, bstate_c = encoder_lstm((encoder_inputs))\n",
        "state_h = Concatenate()([fstate_h,bstate_h])\n",
        "state_c = Concatenate()([bstate_h,bstate_c])\n",
        "\n",
        "encoder_states = [state_h, state_c]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y-tsdAwfhxYy",
        "colab_type": "text"
      },
      "source": [
        "Create Decoder:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-01-22T22:23:22.264487Z",
          "start_time": "2020-01-22T22:23:18.867Z"
        },
        "id": "pPbHH3lVhxY1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Define inputs to the decoder.\n",
        "decoder_inputs = Input(batch_input_shape=(batch,None,train_targets.shape[2]))\n",
        "#decoder_inputs = Input(batch_shape=(batch,features.shape[1],features.shape[2]))\n",
        "\n",
        "#decoder_inputs = Input(batch_shape=(batch,None,train_targets.shape[2]))\n",
        "#dec_input = np.zeros((train_features.shape[0],train_targets.shape[1],train_features.shape[2]))\n",
        "\n",
        "\n",
        "# Create Decoder...\n",
        "decoder_lstm = (LSTM(n_units, return_state=True, return_sequences=True,stateful=False))\n",
        "# Important step: connect Decoder to our input layers and use the hidden and cell states \n",
        "# from the encoder to instantiate this layer\n",
        "\n",
        "decoder_outputs, _, _ = decoder_lstm(decoder_inputs, initial_state=[state_h, state_c])\n",
        "\n",
        "#create attention layer\n",
        "# ----------------------\n",
        "attention = dot([decoder_outputs, encoder_outputs], axes=[2, 2])\n",
        "attention = Activation('softmax')(attention)\n",
        "\n",
        "context = dot([attention, encoder_outputs], axes=[2,1])\n",
        "decoder_combined_context = concatenate([context, decoder_outputs])\n",
        "# ----------------------\n",
        "\n",
        "decoder_dense1 = (Dense(150, activation='tanh'))\n",
        "dropout = Dropout(0.5)\n",
        "decoder_dense2 = Dense(train_targets.shape[2],activation='linear')\n",
        "\n",
        "dense1 = decoder_dense1(decoder_combined_context)\n",
        "drop = dropout(dense1)\n",
        "\n",
        "decoder_outputs = decoder_dense2(drop)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-01-22T22:23:22.268016Z",
          "start_time": "2020-01-22T22:23:18.869Z"
        },
        "id": "l6mSzUxvhxY9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "model = Model(inputs=[encoder_inputs, decoder_inputs], outputs=decoder_outputs)\n",
        "\n",
        "model.compile(optimizer='adam',\n",
        "             loss=mse_nan,\n",
        "             metrics=[mse_nan])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-01-22T22:23:22.271537Z",
          "start_time": "2020-01-22T22:23:18.885Z"
        },
        "id": "ntiMsXovhxZE",
        "colab_type": "code",
        "outputId": "f4746eb9-5d54-4033-cf7f-dcfdd3d406f7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 625
        }
      },
      "source": [
        "model.summary()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Model: \"model\"\n",
            "__________________________________________________________________________________________________\n",
            "Layer (type)                    Output Shape         Param #     Connected to                     \n",
            "==================================================================================================\n",
            "input_2 (InputLayer)            [(None, 36, 44)]     0                                            \n",
            "__________________________________________________________________________________________________\n",
            "input_3 (InputLayer)            [(None, None, 3)]    0                                            \n",
            "__________________________________________________________________________________________________\n",
            "lstm_3 (LSTM)                   [(None, 36, 36), (No 11664       input_2[0][0]                    \n",
            "__________________________________________________________________________________________________\n",
            "lstm_4 (LSTM)                   [(None, None, 36), ( 5760        input_3[0][0]                    \n",
            "                                                                 lstm_3[0][1]                     \n",
            "                                                                 lstm_3[0][2]                     \n",
            "__________________________________________________________________________________________________\n",
            "dot (Dot)                       (None, None, 36)     0           lstm_4[0][0]                     \n",
            "                                                                 lstm_3[0][0]                     \n",
            "__________________________________________________________________________________________________\n",
            "activation (Activation)         (None, None, 36)     0           dot[0][0]                        \n",
            "__________________________________________________________________________________________________\n",
            "dot_1 (Dot)                     (None, None, 36)     0           activation[0][0]                 \n",
            "                                                                 lstm_3[0][0]                     \n",
            "__________________________________________________________________________________________________\n",
            "concatenate_4 (Concatenate)     (None, None, 72)     0           dot_1[0][0]                      \n",
            "                                                                 lstm_4[0][0]                     \n",
            "__________________________________________________________________________________________________\n",
            "dense (Dense)                   (None, None, 150)    10950       concatenate_4[0][0]              \n",
            "__________________________________________________________________________________________________\n",
            "dropout (Dropout)               (None, None, 150)    0           dense[0][0]                      \n",
            "__________________________________________________________________________________________________\n",
            "dense_1 (Dense)                 (None, None, 3)      453         dropout[0][0]                    \n",
            "==================================================================================================\n",
            "Total params: 28,827\n",
            "Trainable params: 28,827\n",
            "Non-trainable params: 0\n",
            "__________________________________________________________________________________________________\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-01-22T22:23:22.274823Z",
          "start_time": "2020-01-22T22:23:18.889Z"
        },
        "id": "s-a_AnSthxZQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#define inference ('inf') model:\n",
        "encoder_model = Model(encoder_inputs, [encoder_outputs,encoder_states]) \n",
        "# ^^^ set up a separate encoding model. This just outputs our encoder states\n",
        "\n",
        "inf_encoder_outputs, inf_encoder_states = encoder_model(encoder_inputs)\n",
        "\n",
        "decoder_state_input_h = Input(shape=(n_units,)) # define shape of hidden state\n",
        "decoder_state_input_c = Input(shape=(n_units,)) # same thing here for cell state\n",
        "decoder_states_inputs = [decoder_state_input_h, decoder_state_input_c]\n",
        "# ^^^ set as state shapes, which tells our decoder to accepts inputs states of the specificed size\n",
        "\n",
        "# create our decoding layer. accepts same shape as decoder inputs and encoder states\n",
        "inf_decoder_outputs, inf_state_h, inf_state_c = decoder_lstm(decoder_inputs, initial_state=decoder_states_inputs)\n",
        "\n",
        "# save decoder output states. We'll use these as the input states for our decoder for predicting each next timestep\n",
        "# after the initial input of our encoder states\n",
        "decoder_states = [inf_state_h, inf_state_c]\n",
        "\n",
        "inf_attention = dot([inf_decoder_outputs, inf_encoder_outputs], axes=[2, 2])\n",
        "inf_attention = Activation('softmax')(inf_attention)\n",
        "\n",
        "inf_context = dot([inf_attention, inf_encoder_outputs], axes=[2,1])\n",
        "inf_decoder_combined_context = concatenate([inf_context, inf_decoder_outputs])\n",
        "\n",
        "\n",
        "inf_dense1 = decoder_dense1(inf_decoder_combined_context)\n",
        "inf_drop = dropout(inf_dense1)\n",
        "\n",
        "inf_final_outputs = decoder_dense2(inf_drop)\n",
        "# finally, instantiate our decoder model. Inputs are the original sequence + the encoder states. \n",
        "# outputs: sequence prediction + the states used for the decoder\n",
        "decoder_model = Model([encoder_inputs,decoder_inputs] + decoder_states_inputs, [inf_final_outputs]+decoder_states)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-01-22T22:23:22.277273Z",
          "start_time": "2020-01-22T22:23:18.894Z"
        },
        "id": "sZvx8u6VhxZV",
        "colab_type": "code",
        "outputId": "46bcf4d7-e7cc-4c95-8db7-e4ee92cb699f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 694
        }
      },
      "source": [
        "decoder_model.summary()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Model: \"model_2\"\n",
            "__________________________________________________________________________________________________\n",
            "Layer (type)                    Output Shape         Param #     Connected to                     \n",
            "==================================================================================================\n",
            "input_3 (InputLayer)            [(None, None, 3)]    0                                            \n",
            "__________________________________________________________________________________________________\n",
            "input_4 (InputLayer)            [(None, 36)]         0                                            \n",
            "__________________________________________________________________________________________________\n",
            "input_5 (InputLayer)            [(None, 36)]         0                                            \n",
            "__________________________________________________________________________________________________\n",
            "input_2 (InputLayer)            [(None, 36, 44)]     0                                            \n",
            "__________________________________________________________________________________________________\n",
            "lstm_4 (LSTM)                   [(None, None, 36), ( 5760        input_3[0][0]                    \n",
            "                                                                 input_4[0][0]                    \n",
            "                                                                 input_5[0][0]                    \n",
            "__________________________________________________________________________________________________\n",
            "model_1 (Model)                 [(None, 36, 36), [(N 11664       input_2[0][0]                    \n",
            "__________________________________________________________________________________________________\n",
            "dot_2 (Dot)                     (None, None, 36)     0           lstm_4[1][0]                     \n",
            "                                                                 model_1[1][0]                    \n",
            "__________________________________________________________________________________________________\n",
            "activation_1 (Activation)       (None, None, 36)     0           dot_2[0][0]                      \n",
            "__________________________________________________________________________________________________\n",
            "dot_3 (Dot)                     (None, None, 36)     0           activation_1[0][0]               \n",
            "                                                                 model_1[1][0]                    \n",
            "__________________________________________________________________________________________________\n",
            "concatenate_5 (Concatenate)     (None, None, 72)     0           dot_3[0][0]                      \n",
            "                                                                 lstm_4[1][0]                     \n",
            "__________________________________________________________________________________________________\n",
            "dense (Dense)                   (None, None, 150)    10950       concatenate_5[0][0]              \n",
            "__________________________________________________________________________________________________\n",
            "dropout (Dropout)               (None, None, 150)    0           dense[1][0]                      \n",
            "__________________________________________________________________________________________________\n",
            "dense_1 (Dense)                 (None, None, 3)      453         dropout[1][0]                    \n",
            "==================================================================================================\n",
            "Total params: 28,827\n",
            "Trainable params: 28,827\n",
            "Non-trainable params: 0\n",
            "__________________________________________________________________________________________________\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-01-22T22:58:37.863377Z",
          "start_time": "2020-01-22T22:58:37.793834Z"
        },
        "id": "JBzLqzyqhxZd",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Let's define a small function that predicts based on the trained encoder and decoder models\n",
        "# Function adapted from https://github.com/LukeTonin/keras-seq-2-seq-signal-prediction\n",
        "def predict(x, encoder_predict_model, decoder_predict_model, num_steps_to_predict, \n",
        "            num_features_to_predict, batch_size=None):\n",
        "    \"\"\"Predict time series with encoder-decoder.\n",
        "    \n",
        "    Uses the encoder and decoder models previously trained to predict the next\n",
        "    num_steps_to_predict values of the time series.\n",
        "    \n",
        "    Arguments\n",
        "    ---------\n",
        "    x: input time series of shape (batch_size, input_sequence_length, input_dimension).\n",
        "    encoder_predict_model: The Keras encoder model.\n",
        "    decoder_predict_model: The Keras decoder model.\n",
        "    num_steps_to_predict: The number of steps in the future to predict\n",
        "    num_features_to_predict: The number of features we want to predict per timestep\n",
        "    \n",
        "    Returns\n",
        "    -------\n",
        "    y_predicted: output time series for shape (batch_size, target_sequence_length,\n",
        "        ouput_dimension)\n",
        "    \"\"\"\n",
        "    y_predicted = []\n",
        "\n",
        "    # Encode the values as a state vector\n",
        "    enc_outputs_and_states = encoder_predict_model.predict(x,batch_size=batch)\n",
        "    #print(len(enc_outputs_and_states))\n",
        "\n",
        "    # The states must be a list\n",
        "    if not isinstance(enc_outputs_and_states, list):\n",
        "        enc_outputs_and_states = [enc_outputs_and_states]\n",
        "\n",
        "    enc_outputs = enc_outputs_and_states[0]\n",
        "    states = enc_outputs_and_states[1:]\n",
        "    #decoder_input = np.zeros((x.shape[0], 1, num_features_to_predict))\n",
        "    decoder_input = x[:,-1:,-num_features_to_predict:] \n",
        "    # '-num_features_to_predict:' assumes the targets are the final columns\n",
        "\n",
        "    for _ in range(num_steps_to_predict):\n",
        "        outputs_and_states = decoder_predict_model.predict(\n",
        "        [x, decoder_input] + states, batch_size=batch)\n",
        "        output = outputs_and_states[0]\n",
        "        states = outputs_and_states[1:]\n",
        "\n",
        "        # add predicted value\n",
        "        y_predicted.append(output)\n",
        "        #decoder_input = output\n",
        "\n",
        "    return np.concatenate(y_predicted, axis=1)\n",
        "    "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-01-22T22:23:35.172641Z",
          "start_time": "2020-01-22T22:23:30.880461Z"
        },
        "scrolled": true,
        "id": "1NQ4kvBRhxZi",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for i in range(1000):\n",
        "    print('epoch: '+str(i))\n",
        "    model.fit([train_features,train_features[:,-36:,-3:]], train_targets, \n",
        "              epochs=1, batch_size=100, verbose=1, shuffle=True)\n",
        "    #model.reset_states()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aAwzmwcEhxZu",
        "colab_type": "text"
      },
      "source": [
        "Evaluate Model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D6hNToaQ66SJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "npwp_predictions = predict(test_features, encoder_model, decoder_model, \n",
        "                      num_steps_to_predict=train_targets.shape[1], num_features_to_predict=train_targets.shape[2],\n",
        "                     batch_size=batch)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-01-22T22:58:52.756325Z",
          "start_time": "2020-01-22T22:58:51.031435Z"
        },
        "id": "DM5l6E8YhxZ7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "ppwp_predictions = predict(ppwp_f_scaled_re, encoder_model, decoder_model, \n",
        "                      num_steps_to_predict=train_targets.shape[1], num_features_to_predict=train_targets.shape[2],\n",
        "                     batch_size=batch)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J_p3NFPPeeOi",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "ppwp_preds = pd.DataFrame(\n",
        "    np.reshape(ppwp_predictions,(ppwp_predictions.shape[0]*ppwp_predictions.shape[1],\n",
        "                                 ppwp_predictions.shape[2])),index=ppwp_ti)\n",
        "ppwp_tests = pd.DataFrame(np.reshape(ppwp_t,(ppwp_t.shape[0]*ppwp_t.shape[1],ppwp_t.shape[2])),index=ppwp_ti)\n",
        "\n",
        "npwp_preds = pd.DataFrame(\n",
        "    np.reshape(npwp_predictions,(npwp_predictions.shape[0]*npwp_predictions.shape[1],\n",
        "                                 npwp_predictions.shape[2])),index=test_indices)\n",
        "npwp_tests = pd.DataFrame(np.reshape(test_targets,(test_targets.shape[0]*\n",
        "                                      test_targets.shape[1],test_targets.shape[2])),index=test_indices)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1A4W4mvJxrvt",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "npwp_ti_reshape = npwp_ti.reshape(npwp_t.shape[0],npwp_t.shape[1])\n",
        "ppwp_ti_reshape = ppwp_ti.reshape(ppwp_t.shape[0],ppwp_t.shape[1])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dhQHdkqhBUdA",
        "colab_type": "code",
        "outputId": "37f08581-f439-4133-ac9b-100461bc2008",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 645
        }
      },
      "source": [
        "import matplotlib.lines as mlines\n",
        "col_list = ['Pore Water Pressures - 63cm',\n",
        "       'Pore Water Pressures - 113cm', 'Pore Water Pressures - 244cm']\n",
        "fig, ax = plt.subplots(3,1,figsize=(8,10),sharex=True)\n",
        "i = 1\n",
        "for col in col_list:\n",
        "    while i < (len(col_list)+1):\n",
        "      ax1 = ax[i-1]\n",
        "\n",
        "      for batch in range(0,npwp_t.shape[0],1):\n",
        "        ax1.plot(npwp_ti_reshape[batch,:],npwp_t[batch,:,i-1], \n",
        "                 label='Training Data',c='lightslategray',linestyle='--',alpha=1)\n",
        "        #ax1.plot(test_indices_reshape[batch,:],test_targets[batch,:,i-1], \n",
        "         #        label='test n',c='slategray',linestyle='--',alpha=1)\n",
        "       \n",
        "        #ax1.plot(test_indices_reshape[batch,:],npwp_predictions[batch,:,i-1], label='pred',c='b')\n",
        "      ax1.scatter(all_target_indices,intervals,c='k',marker='|',s=35,alpha=0.5)\n",
        "\n",
        "      for batch in range(0,ppwp_t.shape[0],1):\n",
        "        ax1.plot(ppwp_ti_reshape[batch,:],ppwp_t[batch,:,i-1], label='test p',c='darkslategrey')\n",
        "        ax1.plot(ppwp_ti_reshape[batch,:],ppwp_predictions[batch,:,i-1], label='pred p',c='indianred')\n",
        "      ax1.set_xlim(pd.to_datetime('2012-01-14'),pd.to_datetime('2012-02-14'))\n",
        "      for tick in ax1.get_xticklabels():\n",
        "        tick.set_rotation(45)\n",
        "      ax1.set_ylim(-9,3.5)\n",
        "      #ax1.set_ylabel('Suction (kPa)')\n",
        "\n",
        "      \n",
        "      color = 'royalblue'\n",
        "      ax2 = ax1.twinx()\n",
        "      #ax2.bar(ocr.index[:],ocr.iloc[:,1],width=0.2,color=color,alpha=0.7)\n",
        "      ax2.tick_params(axis='y', labelcolor=color)\n",
        "      ax2.set_ylim(0.8,14)\n",
        "      #ax2.set_ylabel('Rainfall (mm)', color=color)\n",
        "      ax2.axhline(y=4,color='k',linestyle='dotted',alpha=0.5)\n",
        "      \n",
        "      red_line = mlines.Line2D([], [], color='indianred', marker='',\n",
        "                          markersize=15, label='Predictions')\n",
        "      dashed_line = mlines.Line2D([], [], color='lightslategrey', marker='',\n",
        "                          markersize=15, label='Training Data',linestyle='--')\n",
        "      solid_line = mlines.Line2D([], [], color='darkslategrey', marker='',\n",
        "                          markersize=15, label='Test Data',linestyle='-')\n",
        "      vert = mlines.Line2D([], [], color='k', marker='|',\n",
        "                          markersize=15, label='Prediction Interval (36hr)',\n",
        "                           alpha=0.5)\n",
        "      vert.set_linestyle('')\n",
        "\n",
        "      fsize = 12\n",
        "      plt.setp(ax1.get_xticklabels(), fontsize=fsize)\n",
        "      plt.setp(ax1.get_yticklabels(), fontsize=fsize)\n",
        "      plt.setp(ax2.get_yticklabels(), fontsize=fsize)\n",
        "\n",
        "      if i ==1:\n",
        "          plt.legend(handles=[red_line,dashed_line,solid_line,vert],loc='upper center',\n",
        "                     fontsize='small',bbox_to_anchor=(0.51,1.01),ncol=4,\n",
        "                     markerscale=0.45,frameon=False)\n",
        "          #plt.title(('Soil Matric Potential'))\n",
        "      \n",
        "      \n",
        "      i = i+1\n",
        "\n",
        "#handles, labels = ax1.get_legend_handles_labels()\n",
        "#fig.legend(handles, labels, loc='upper center')\n",
        "plt.subplots_adjust(hspace=0.1)\n",
        "#plt.tight_layout()\n",
        "#plt.savefig('36hr_48_d150_drop5_mask4mm_JF.svg',dpi=300)\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 576x720 with 6 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1Z3-UsKc6v27",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}