Fine-tuning our models and creating final plots.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from data_pipeline import transformation_pipeline\n",
    "from sklearn.model_selection import train_test_split\n",
    "import tensorflow as tf\n",
    "tf.random.set_seed(2111)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "data = pd.read_csv('content/preprocessed_train.csv')\n",
    "\n",
    "# let's pick the data wiht primary_use==0\n",
    "data = data.query('primary_use==0 & meter==0')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "b_id = [118, 646, 125]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def plot_output(actual, predicted, title, building_idx, avg_loss, avg_rmse):\n",
    "    fig, (ax1, ax2, ax) = plt.subplots(3, 1,  figsize=(30, 15), sharex=True)\n",
    "\n",
    "    fig.suptitle(\n",
    "        f'{title} model for building {building_idx}\\nmse={avg_loss:.5f}\\nrmse={avg_rmse:.5f}', fontsize=24)\n",
    "\n",
    "    ax1.plot(range(len(actual)),\n",
    "             predicted,\n",
    "             color='green', linestyle='dashed')\n",
    "    ax1.set_title('Predicted')\n",
    "    ax1.set_ylim(0, 1)\n",
    "\n",
    "    ax2.plot(range(len(actual)),\n",
    "             actual,\n",
    "             color='red', label='Actual')\n",
    "    ax2.set_title('Actual')\n",
    "    ax2.set_ylim(0, 1)\n",
    "\n",
    "    ax.plot(range(len(actual)),\n",
    "            predicted,\n",
    "            color='green', linestyle='dashed',\n",
    "            label='Predicted')\n",
    "\n",
    "    ax.plot(range(len(actual)),\n",
    "            actual,\n",
    "            color='red',\n",
    "            label='actual')\n",
    "    ax.set_ylim(0, 1)\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "    fig.savefig(\n",
    "        f'Final Plots for the research/tune on 20/{title} model -- building {building_idx} -- mse {avg_loss:.5f} -- rmse {avg_rmse:.5f}.png')\n",
    "\n",
    "# %%\n",
    "\n",
    "# function to laod certain building id\n",
    "\n",
    "\n",
    "def loading_data(idx, train_size):\n",
    "    pipeline, data_cleaned = transformation_pipeline(\n",
    "        data, building_id=idx, meter=0, primary_use=0)\n",
    "\n",
    "    train, test = train_test_split(data_cleaned,\n",
    "                                   # [:, 1:],\n",
    "                                   #transformed_data[:, 0],\n",
    "                                   train_size=train_size,\n",
    "                                   shuffle=False,\n",
    "                                   random_state=2021)\n",
    "\n",
    "    train_data = pipeline.fit_transform(train)\n",
    "    test_data = pipeline.transform(test)\n",
    "\n",
    "    x_train, y_train = train_data[:, 1:], train_data[:, 0]\n",
    "\n",
    "    x_val, y_val = test_data[:, 1:], test_data[:, 0]\n",
    "\n",
    "    train_gen = tf.keras.preprocessing.sequence.TimeseriesGenerator(x_train,\n",
    "                                                                    y_train,\n",
    "                                                            length=6, sampling_rate=1,\n",
    "                                                             stride=1,\n",
    "                                                             batch_size=32,\n",
    "                                                                shuffle=False)\n",
    "\n",
    "    val_gen = tf.keras.preprocessing.sequence.TimeseriesGenerator(x_val,\n",
    "                                                                  y_val,\n",
    "                                                      length=6, sampling_rate=1,\n",
    "                                                      stride=1, batch_size=350,\n",
    "                                                      shuffle=False\n",
    "                                                      )\n",
    "    return train_gen, val_gen[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "pd.options.mode.chained_assignment = None\n",
    "# %% loading models to evaluate them on new data\n",
    "import time\n",
    "\n",
    "\n",
    "transformer_model = tf.keras.models.load_model('models/Transformer_adam')\n",
    "lstm_model = tf.keras.models.load_model('models/LSTM_ADAM')\n",
    "rnn_model = tf.keras.models.load_model('models/RNN_ADAM')\n",
    "\n",
    "models =[transformer_model, lstm_model, rnn_model ]\n",
    "\n",
    "i2txt={0:'transformer', 1:'lstm', 2:'rnn'}\n",
    "\n",
    "finetuning_data = {}\n",
    "for building_idx in b_id:\n",
    "    train_gen, test_gen = loading_data(building_idx, 0.2)\n",
    "    finetuning_data[building_idx] = {}\n",
    "    for i , model in enumerate(models):\n",
    "        predicted = np.array([])\n",
    "        actual = np.array([])\n",
    "\n",
    "        txt = i2txt[i]\n",
    "\n",
    "        finetuning_data[building_idx][txt] = []\n",
    "\n",
    "        #model = tf.keras.models.load_model(model_address)\n",
    "\n",
    "       # start_time = time.time()\n",
    "\n",
    "        model.fit(train_gen, epochs=15, verbose=False)\n",
    "\n",
    "\n",
    "        \n",
    "\n",
    "       # time_taken = time.time() - start_time\n",
    "       # print(f\"model {txt} took {time.time() - start_time} seconds\")\n",
    "\n",
    "        predicted = np.append(predicted, model.predict(test_gen[0]))\n",
    "        actual = np.append(actual, test_gen[1])\n",
    "\n",
    "        # avg_mse = np.mean((actual - predicted)**2)\n",
    "        # avg_rmse = np.sqrt(np.mean((actual - predicted)**2))\n",
    "\n",
    "        # #finetuning_data[building_idx][txt].append(\n",
    "        # #    (avg_mse, avg_rmse, time_taken))\n",
    "\n",
    "        # mape= np.mean(np.abs(np.divide((predicted - actual),(actual + 1e-15))))\n",
    "\n",
    "        # print(f'{txt} Model \\nbuilding: {building_idx} \\nmse= {avg_mse} \\nrmse] {avg_rmse} \\nmape= {mape}\\n----------')\n",
    "\n",
    "        #plot_output(actual, predicted, txt, building_idx, avg_mse, avg_rmse)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# transformer, gru, lstm,rnn = [], [], [],[]\n",
    "# for building_idx in b_id:\n",
    "\n",
    "#     x, y, z,r = finetuning_data[building_idx].values()\n",
    "#     transformer.append(x)\n",
    "#     gru.append(y)\n",
    "#     lstm.append(z)\n",
    "#     rnn.append(r)\n",
    "# # %%\n",
    "# mse, rmse, t = [], [], []\n",
    "# for d in [transformer, gru, lstm,rnn]:\n",
    "#     for i in range(3):\n",
    "\n",
    "#         mse.append(d[i][0][0])\n",
    "#         rmse.append(d[i][0][1])\n",
    "#         t.append(d[i][0][2])\n",
    "\n",
    "#     d.append([np.mean(mse), np.mean(rmse), np.mean(t)])\n",
    "\n",
    "# # %%\n",
    "# for d, n in zip([transformer, gru, lstm,rnn], ['transformer', 'gru',\n",
    "#                                                'lstm','rnn']):\n",
    "#     print(f'--- {n} ---')\n",
    "#     print(' mse \\t rmse \\t time')\n",
    "#     print(f'{d[3][0]:0.4f}\\t{d[3][1]:0.4f}\\t{d[3][2]:0.4f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loading_data_adjusted(idx, train_size):\n",
    "    pipeline, data_cleaned = transformation_pipeline(\n",
    "        data, building_id=idx, meter=0, primary_use=0)\n",
    "\n",
    "    train, test = train_test_split(data_cleaned,\n",
    "                                   # [:, 1:],\n",
    "                                   #transformed_data[:, 0],\n",
    "                                   train_size=train_size,\n",
    "                                   shuffle=False,\n",
    "                                   random_state=2021)\n",
    "\n",
    "    train_data = pipeline.fit_transform(train)\n",
    "    test_data = pipeline.transform(test)\n",
    "\n",
    "    x_train, y_train = train_data[:, 1:], train_data[:, 0]\n",
    "\n",
    "    x_val, y_val = test_data[:, 1:], test_data[:, 0]\n",
    "\n",
    "    train_gen = tf.keras.preprocessing.sequence.TimeseriesGenerator(x_train,\n",
    "                                                                    y_train,\n",
    "                                                            length=6, sampling_rate=1,\n",
    "                                                             stride=1,\n",
    "                                                             batch_size=32,\n",
    "                                                                shuffle=False)\n",
    "\n",
    "    val_gen = tf.keras.preprocessing.sequence.TimeseriesGenerator(x_val,\n",
    "                                                                  y_val,\n",
    "                                                      length=6, sampling_rate=1,\n",
    "                                                      stride=1, batch_size=350,\n",
    "                                                      shuffle=False\n",
    "                                                      )\n",
    "    return train_gen, val_gen[3]\n",
    "\n",
    "\n",
    "\n",
    "transformer_predicted= np.array([])\n",
    "lstm_predicted= np.array([])\n",
    "rnn_predicted= np.array([])\n",
    "actual=  np.array([])\n",
    "_, test_gen = loading_data_adjusted( 118 , 0.2)\n",
    "\n",
    "\n",
    "transformer_predicted = np.append(transformer_predicted, transformer_model.predict(test_gen[0][100:268] ))\n",
    "lstm_predicted = np.append(lstm_predicted, lstm_model.predict(test_gen[0][100:268] ))\n",
    "rnn_predicted = np.append(rnn_predicted, rnn_model.predict(test_gen[0][100:268] ))\n",
    "\n",
    "actual = np.append(actual, test_gen[1][100:268] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "testing to get the best results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# def loading_data_adjusted(idx, train_size):\n",
    "#     pipeline, data_cleaned = transformation_pipeline(\n",
    "#                             data, building_id=idx, meter=0, primary_use=0)\n",
    "\n",
    "#     train, test = train_test_split(data_cleaned,\n",
    "#                                    # [:, 1:],\n",
    "#                                    #transformed_data[:, 0],\n",
    "#                                    train_size=train_size,\n",
    "#                                    shuffle=False,\n",
    "#                                    random_state=2021)\n",
    "\n",
    "#     train_data = pipeline.fit_transform(train)\n",
    "#     test_data = pipeline.transform(test)\n",
    "\n",
    "#     x_train, y_train = train_data[:, 1:], train_data[:, 0]\n",
    "\n",
    "#     x_val, y_val = test_data[:, 1:], test_data[:, 0]\n",
    "\n",
    "#     train_gen = tf.keras.preprocessing.sequence.TimeseriesGenerator(x_train,\n",
    "#                                                                     y_train,\n",
    "#                                                             length=6, sampling_rate=1,\n",
    "#                                                              stride=1,\n",
    "#                                                              batch_size=32,\n",
    "#                                                                 shuffle=False)\n",
    "\n",
    "#     val_gen = tf.keras.preprocessing.sequence.TimeseriesGenerator(x_val,\n",
    "#                                                                   y_val,\n",
    "#                                                       length=6, sampling_rate=1,\n",
    "#                                                       stride=1, batch_size=350,\n",
    "#                                                       shuffle=False\n",
    "#                                                       )\n",
    "#     return train_gen, val_gen[0]\n",
    "\n",
    "\n",
    "\n",
    "# transformer_predicted= np.array([])\n",
    "# lstm_predicted= np.array([])\n",
    "# rnn_predicted= np.array([])\n",
    "# actual=  np.array([])\n",
    "\n",
    "# #_, test_gen = loading_data_adjusted( 118 , 0.2)\n",
    "# test_gen, _ = loading_data_adjusted( 118 , 0.2)\n",
    "# for i in range(20,30):\n",
    "#     transformer_predicted = np.append(transformer_predicted, transformer_model.predict(test_gen[i][0] ))\n",
    "#     lstm_predicted = np.append(lstm_predicted, lstm_model.predict(test_gen[i][0]  ))\n",
    "#     rnn_predicted = np.append(rnn_predicted, rnn_model.predict(test_gen[i][0]  ))\n",
    "\n",
    "#     actual = np.append(actual, test_gen[i][1] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "fig, ax = plt.subplots(1, 1,  figsize=(10, 4))\n",
    "\n",
    "#ax.set_title( 'Different Model Outputs', fontsize=45)\n",
    "\n",
    "ax.plot(\n",
    "        transformer_predicted,\n",
    "        color='green', linestyle='-', linewidth=2,\n",
    "        label='Transformer')\n",
    "\n",
    "ax.plot(\n",
    "        lstm_predicted,\n",
    "        color='pink', linestyle='-', linewidth=2 ,\n",
    "        label='LSTM')\n",
    "\n",
    "ax.plot(\n",
    "        rnn_predicted,\n",
    "        color='gray',  linestyle='-', linewidth=2 ,\n",
    "        label='RNN')\n",
    "\n",
    "ax.plot(\n",
    "        actual,\n",
    "        color='black', marker='.'  ,linestyle='-', linewidth=2,\n",
    "        label='actual')\n",
    "\n",
    "# ax.set_yticks([])\n",
    "# ax.set_xticks([])\n",
    "\n",
    "ax.set_xlabel('Week ahead (Hours)',fontsize=23)\n",
    "ax.set_ylabel('Load (Normalized)', fontsize=23)\n",
    "plt.xticks( fontsize=13)\n",
    "plt.yticks(fontsize=13)\n",
    "#ax.set_ylim(0, 1)\n",
    "plt.legend(fontsize=12)\n",
    "plt.grid(True)\n",
    "\n",
    "plt.show()\n",
    "\n",
    "fig.savefig( f'Final Plots for the research/diff_models.png', bbox_inches='tight', dpi=2000)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}