EL_GRU_Day2Day_BySeason_2021.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import plotly.express as px\n",
    "import plotly.graph_objects as go\n",
    "from plotly.subplots import make_subplots\n",
    "from plotly.offline import init_notebook_mode\n",
    "init_notebook_mode(connected=False)\n",
    "pd.set_option('display.max_colwidth', 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from sklearn.model_selection import KFold, train_test_split, StratifiedKFold\n",
    "from sklearn.ensemble import RandomForestRegressor, AdaBoostRegressor, ExtraTreesRegressor\n",
    "from sklearn.metrics import accuracy_score, mean_absolute_error, mean_squared_error\n",
    "from sklearn.linear_model import Ridge, Lasso, ElasticNet\n",
    "from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler\n",
    "from evaluation_metrics import compute_metrics, compute_metrics_csv, mean_absolute_percentage_error, symetric_mean_absolute_percentage_error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from statsmodels.tsa.stattools import acf, pacf, ccf, ccovf\n",
    "from statsmodels.tsa.seasonal import STL\n",
    "from statsmodels.graphics.tsaplots import plot_acf, plot_pacf \n",
    "from statsmodels.tsa.stattools import adfuller, kpss\n",
    "from scipy.stats import boxcox, yeojohnson\n",
    "from scipy.spatial.distance import cosine, euclidean\n",
    "import rstl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from scipy.stats import boxcox, yeojohnson"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from tqdm.notebook import trange, tqdm\n",
    "from datetime import datetime\n",
    "import itertools\n",
    "from numpy.polynomial import Polynomial as P"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import pickle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import ruptures as rpt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from river import tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import warnings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import LSTM, Dense, GRU, Flatten\n",
    "from tensorflow import random as tf_random\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "SEED = 13\n",
    "tf_random.set_seed(SEED)\n",
    "np.random.seed(SEED)\n",
    "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"2\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "warnings.simplefilter(action='ignore', category=pd.errors.PerformanceWarning)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df = pd.read_csv('./Data/ppnet_metar_v8_2021.csv', sep=';', index_col=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df = df[df.Year < 2021].copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df_temp_forecast = pd.read_csv('./Data/yrno_temperature.csv', sep=';', index_col=0, decimal=',')\n",
    "df_temp_forecast.index = pd.DatetimeIndex(pd.Series(df_temp_forecast.index).apply(lambda x: datetime.strptime(x, '%d.%m.%Y %H:%M')))\n",
    "df_temp_forecast = df_temp_forecast.iloc[:, 1].groupby(df_temp_forecast.index).mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df_el = pd.read_csv('./Data/raw_electricity_2021.csv', sep=',', index_col=0).rename({'Load_ffill': 'Consumption'}, axis=1).Consumption\n",
    "df_el.index = pd.DatetimeIndex(df_el.index)\n",
    "df_el"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df.loc[:, 'TestSet'] = 0\n",
    "df.loc[df.Year == 2020, 'TestSet'] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "px.line(y=df['Consumption'], x=df.index, color=df.Year)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df_gas = pd.read_csv('./Data/ppnet_metar_v8_2021.csv', sep=';', index_col=0)\n",
    "df_gas.index = pd.DatetimeIndex(df_gas.index)\n",
    "df_gas['Month'] = df_gas.index.month_name()\n",
    "df_gas['Day'] = df_gas.index.day_name()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df.index = pd.DatetimeIndex(df.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "temp_err = (df.Temperature - df.Temperature_YRNO).dropna()\n",
    "temp_err.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df.isna().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df.describe(exclude='O').columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "FORECAST_HORIZON = 24"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df.loc[df.index <= '2014-12-31 23:00:00', 'Temperature_YRNO'] = df.loc[df.index <= '2014-12-31 23:00:00', 'Temperature']\n",
    "df.loc[:, 'Temperature_YRNO'] = df.loc[:, 'Temperature_YRNO'].interpolate()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "X, y = df.loc[:, df.columns != 'Consumption'].copy(), df_el[df_el.index.isin(df.index)].copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "X.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "X.isna().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "y.isna().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "X.Cena.bfill()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "X['Cena_bfill'] = X.Cena.bfill()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "X = X.loc[:, ['Year', 'Month', 'Day', 'Hour', 'Day_of_week', 'Before_holiday', 'Holiday', 'Temperature', 'Temperature_YRNO', 'Wind_speed', 'Humidity']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_scaler, y_scaler = MinMaxScaler(), MinMaxScaler()\n",
    "X_scaler.fit(X.loc[X.index.year == 2013])\n",
    "X_scaled = pd.DataFrame(X_scaler.transform(X), columns=X.columns, index=X.index)\n",
    "\n",
    "y_scaler.fit(y[X.index.year == 2013].values.reshape(-1, 1))\n",
    "y_scaled = y_scaler.transform(y.values.reshape(-1, 1))\n",
    "y_scaled = pd.DataFrame(y_scaled, columns=['Consumption'], index=y.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_lstm_dataset(X, y, lags=72, future_steps=24):\n",
    "    lagged_columns = ['Temperature', 'Temperature_YRNO', 'Wind_speed', 'Humidity', 'Month', 'Day', 'Hour', 'Day_of_week', 'Before_holiday',\n",
    "       'Holiday', 'Consumption']\n",
    "    df_combined = pd.concat([X, y], axis=1)\n",
    "    X_selected = df_combined.loc[:, lagged_columns].dropna()\n",
    "\n",
    "    X_seq, y_seq, index_seq = [], [], []\n",
    "    for i in trange(len(X_selected) - lags - future_steps):\n",
    "        X_past = X_selected.iloc[i:i+lags, :-1].values\n",
    "        future_temp = X_selected.iloc[i+lags:i+lags+future_steps, 2].values\n",
    "        padded = np.pad(future_temp, (0, lags - len(future_temp)), 'constant', constant_values=0.0)\n",
    "        X_with_future_temp = np.append(X_past, padded.reshape(-1, 1), axis=1)\n",
    "        current_index = X_selected.iloc[i+lags:i+lags+future_steps, -1].index\n",
    "\n",
    "        if current_index[0].hour != 0:\n",
    "            continue\n",
    "\n",
    "        X_seq.append(X_with_future_temp)\n",
    "        y_seq.append(X_selected.iloc[i+lags:i+lags+future_steps, -1].values)\n",
    "        index_seq.append(current_index)\n",
    "\n",
    "    X_seq = np.array(X_seq)\n",
    "    y_seq = np.array(y_seq)\n",
    "    index_seq = np.array(index_seq)\n",
    "\n",
    "    return X_seq, y_seq, index_seq\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def create_lagged_dataset(X, y, past_lags=24, future_temp_forecast_lags=24):\n",
    "    X_in, y_out = X.copy().drop(['Year'], axis=1), pd.DataFrame(columns=[f'H{x}' for x in range(1, 25)], index=y.index)\n",
    "    \n",
    "    for i, x in enumerate(y_out.columns):\n",
    "        y_out[f'H{i+1}'] = y.shift(-i-1)\n",
    "    \n",
    "    lagged_columns = ['Temperature', 'Temperature_YRNO', 'Wind_speed', 'Humidity']\n",
    "    for c in lagged_columns:\n",
    "        for i in range(1, past_lags+1):\n",
    "            X_in[f'LAG_{c}_{i}'] = X[c].shift(i)\n",
    "    \n",
    "    for i in range(1, future_temp_forecast_lags + 1):\n",
    "        c = 'Temperature_YRNO'\n",
    "        X_in[f'LAG_{c}_{i}'] = X[c].shift(-i)\n",
    "        \n",
    "    for i in range(1, past_lags + 1):\n",
    "        c = 'Consumption'\n",
    "        X_in[f'LAG_{c}_{i}'] = y.shift(i)\n",
    "    \n",
    "    return (X_in, y_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "past_lags, future_steps = 72, 24\n",
    "X_in, y_out, index_seq = create_lstm_dataset(X_scaled, y_scaled, past_lags, future_steps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_in_orig, y_out_orig, _ = create_lstm_dataset(X, y, past_lags, future_steps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_in.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_out.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "index_seq.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "index_seq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def plot_bkps(data, my_bkps, title=None, ret=False):\n",
    "    fig = go.Figure()\n",
    "    fig.add_trace(go.Scatter(x=data.index, y=data.values,\n",
    "                            mode='lines',\n",
    "                            line_color='#333C83'))\n",
    "    # fig = px.line(x=data.index, y=data.values, title=title)\n",
    "    clr_selection = 'green'\n",
    "    color_switch = lambda x: 'blue' if x != 'blue' else 'green'\n",
    "\n",
    "    for idx, cp in enumerate(my_bkps):\n",
    "        if cp >= len(data):\n",
    "            break\n",
    "\n",
    "        fig.add_vline(x=data.index[cp], line_width=3, line_dash=\"dash\", line_color=\"red\")\n",
    "\n",
    "        if idx < len(my_bkps) - 2:\n",
    "            clr_selection = color_switch(clr_selection)\n",
    "            fig.add_vrect(x0=data.index[cp], x1=data.index[my_bkps[idx+1]], line_width=0, fillcolor=clr_selection, opacity=0.1)\n",
    "    \n",
    "    # fig.data = fig.data[::-1]\n",
    "    fig.update_layout(title=title)\n",
    "    if ret:\n",
    "        return fig\n",
    "    fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def plot_bkps_selection(data, my_bkps, title=None, ret=False):\n",
    "    fig = go.Figure()\n",
    "    fig.add_trace(go.Scatter(x=data.index, y=data.values,\n",
    "                            mode='lines',\n",
    "                            line_color='#333C83'))\n",
    "    # fig = px.line(x=data.index, y=data.values, title=title)\n",
    "    clr_selection = 'green'\n",
    "    color_switch = lambda x: 'blue' if x != 'blue' else 'green'\n",
    "\n",
    "    for idx, cp in enumerate(my_bkps):\n",
    "        if cp >= len(data):\n",
    "            break\n",
    "\n",
    "        fig.add_vline(x=data.index[cp], line_width=3, line_dash=\"dash\", line_color=\"red\")\n",
    "\n",
    "        if idx < len(my_bkps) - 2:\n",
    "            clr_selection = color_switch(clr_selection)\n",
    "            fig.add_vrect(x0=data.index[cp], x1=data.index[my_bkps[idx+1]], line_width=0, fillcolor=clr_selection, opacity=0.1)\n",
    "    \n",
    "    # fig.data = fig.data[::-1]\n",
    "    fig.update_layout(title=title)\n",
    "    if ret:\n",
    "        return fig\n",
    "    fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_in_nona_midnight, y_out_nona_midnight = X_in, y_out\n",
    "# X_in_nona_midnight, y_out_nona_midnight = X_in_nona_midnight.iloc[1:, :], y_out_nona_midnight.iloc[1:, :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ANN_SIZE = {\n",
    "    'BIG': [256, 128], \n",
    "    'MEDIUM': [128, 64], \n",
    "    'SMALL': [64, 32]\n",
    "}\n",
    "\n",
    "SELECTED_SIZE = 'BIG'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_model():\n",
    "    model = Sequential()\n",
    "    model.add(GRU(ANN_SIZE[SELECTED_SIZE][0], input_shape=(X_in_nona_midnight.shape[1],X_in_nona_midnight.shape[2]), activation='relu', return_sequences=True))  # Adjust units as needed\n",
    "    model.add(Flatten())\n",
    "    model.add(Dense(ANN_SIZE[SELECTED_SIZE][1], activation='relu'))  # Adjust units as needed\n",
    "    model.add(Dense(y_out_nona_midnight.shape[1], activation='sigmoid'))  # Output layer with linear activation for regression\n",
    "\n",
    "    model.compile(optimizer='adam', loss='mean_squared_error', metrics=['mae'])\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "models_dict = {}\n",
    "\n",
    "for i in range(1,5):\n",
    "    models_dict[i] = build_model()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "index_seq_midnight = pd.DatetimeIndex(index_seq[:, 0])\n",
    "index_seq_midnight"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df_forecast = pd.DataFrame(columns=[f'H{x}' for x in range(1, 25)], index=index_seq_midnight)\n",
    "limit = X_in_nona_midnight.shape[0]\n",
    "losses = []\n",
    "\n",
    "for i in trange(len(X_in_nona_midnight)):    \n",
    "    instance_X = X_in_nona_midnight[i].reshape(1, X_in_nona_midnight.shape[1], X_in_nona_midnight.shape[2])\n",
    "    instance_y = y_out_nona_midnight[i].reshape(1, y_out_nona_midnight.shape[1])\n",
    "    q = index_seq_midnight[i].quarter\n",
    "    model = models_dict[q]\n",
    "    # Predict before training\n",
    "    predicted_values = model.predict(instance_X)\n",
    "    df_forecast.iloc[i, :] = predicted_values\n",
    "\n",
    "    # Train on the new instance\n",
    "    loss, mae = model.train_on_batch(instance_X, instance_y)\n",
    "    losses.append((loss, mae))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df_forecast"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_forecast_orig = y_scaler.inverse_transform(df_forecast)\n",
    "df_forecast_orig = pd.DataFrame(df_forecast_orig, columns=df_forecast.columns, index=df_forecast.index)\n",
    "df_forecast_orig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df_forecast.shape[0] * df_forecast.shape[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "y_out_selection = y[(y.index >= '2013-01-05 00:00:00') & (y.index <= '2020-12-30 23:00:00')]\n",
    "y_out_selection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_forecast_res = df_forecast_orig[(df_forecast_orig.index <= '2020-12-30') & (df_forecast.index >= '2013-01-05')]\n",
    "df_forecast_res = df_forecast_res.stack().reset_index(name='y_pred')\n",
    "# df_forecast_res.index = y_out_selection.index[72:24*364*2]\n",
    "df_forecast_res.index = y_out_selection.index[0:]\n",
    "\n",
    "df_forecast_res = df_forecast_res.shift()\n",
    "df_forecast_res = df_forecast_res.dropna()\n",
    "df_forecast_res = df_forecast_res.drop(['level_0', 'level_1'], axis=1)\n",
    "df_forecast_res['y_true'] = y_out_selection.iloc[1:]\n",
    "df_forecast_res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df_forecast_res.to_csv(f'Results/EL_GRU_{SELECTED_SIZE}_Day2Day_BySeason_2021.csv', sep=',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# df_forecast_res = pd.read_csv('Results/NGC_HT_Day2Day_BySeason_2021.csv', sep=',', index_col=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df_forecast_res.index = pd.DatetimeIndex(df_forecast_res.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df_forecast_res"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## IQR correction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# q3, q1 = np.percentile(df_forecast_res.y_pred, [75 ,25])\n",
    "# iqr = q3 - q1\n",
    "# qt, qb = q3 + 1.5*iqr, q1 - 1.5*iqr\n",
    "\n",
    "\n",
    "# df_forecast_res['y_pred'] = df_forecast_res['y_pred'].apply(lambda x: np.nan if x > qt or x < qb else x)\n",
    "# df_forecast_res['y_pred'] = df_forecast_res['y_pred'].fillna(method='ffill')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "compute_metrics(df_forecast_res[df_forecast_res.index >= '2013-01-05 00:00:00'].dropna())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "compute_metrics(df_forecast_res[df_forecast_res.index >= '2014-01-01 00:00:00'].dropna())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df_pred_all = pd.DataFrame(columns=['MAE', 'MSE', 'MAPE', 'SMAPE', 'R2', 'WAPE'], index=[x for x in range(2014, 2021)])\n",
    "\n",
    "for year in range(2014, 2021):\n",
    "    tmp = compute_metrics(df_forecast_res[(df_forecast_res.index >= f'{year}-01-01 00:00:00') & (df_forecast_res.index <= f'{year}-12-31 00:00:00')].dropna()).values\n",
    "    df_pred_all.loc[year, :] = tmp\n",
    "df_pred_all"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "compute_metrics(df_forecast_res[(df_forecast_res.index >= '2014-01-01 00:00:00') & (df_forecast_res.index <= '2014-12-31 00:00:00')].dropna())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "compute_metrics(df_forecast_res[(df_forecast_res.index >= '2015-01-01 00:00:00') & (df_forecast_res.index <= '2015-12-31 00:00:00')].dropna())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "compute_metrics(df_forecast_res[(df_forecast_res.index >= '2016-01-01 00:00:00') & (df_forecast_res.index <= '2016-12-31 00:00:00')].dropna())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "compute_metrics(df_forecast_res[(df_forecast_res.index >= '2017-01-01 00:00:00') & (df_forecast_res.index <= '2017-12-31 00:00:00')].dropna())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "compute_metrics(df_forecast_res[(df_forecast_res.index >= '2017-01-01 00:00:00') & (df_forecast_res.index <= '2017-12-31 00:00:00')].dropna())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "compute_metrics(df_forecast_res[(df_forecast_res.index >= '2018-01-01 00:00:00') & (df_forecast_res.index <= '2018-12-31 00:00:00')].dropna())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "compute_metrics(df_forecast_res[(df_forecast_res.index >= '2019-01-01 00:00:00') & (df_forecast_res.index <= '2019-12-31 00:00:00')].dropna())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "compute_metrics(df_forecast_res[(df_forecast_res.index >= '2020-01-01 00:00:00') & (df_forecast_res.index <= '2020-12-31 00:00:00')].dropna())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df_forecast_res_s = df_forecast_res[df_forecast_res.index >= '2013-01-05 00:00:00'].stack().reset_index().rename({'level_1': 'Type', 0: 'Value'}, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df_forecast_res_s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df_err = df_forecast_res[df_forecast_res.index >= '2013-01-05 00:00:00'].copy()\n",
    "df_err.loc[:, 'AE'] = (df_err.y_true - df_err.y_pred).abs()\n",
    "df_err.loc[:, 'SE'] = (df_err.y_true - df_err.y_pred) ** 2\n",
    "df_err.loc[:, 'SAPE'] = ((df_err.y_pred - df_err.y_true).abs() / ((df_err.y_true.abs() + df_err.y_pred.abs())/2)) * 100\n",
    "df_err"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def plot_pred_bkps(data, my_bkps, from_dt=None, title=None, plot_metrics=True):\n",
    "    if from_dt:\n",
    "        data = data[data.index >= from_dt]\n",
    "    my_bkps = [x for x in my_bkps if x < len(data)]\n",
    "    \n",
    "    df_err = data.copy()\n",
    "    df_err.loc[:, 'AE'] = (df_err.y_true - df_err.y_pred).abs()\n",
    "    df_err.loc[:, 'SE'] = (df_err.y_true - df_err.y_pred) ** 2\n",
    "    df_err.loc[:, 'SAPE'] = ((df_err.y_pred - df_err.y_true).abs() / ((df_err.y_true.abs() + df_err.y_pred.abs())/2)) * 100\n",
    "    \n",
    "    fig = go.Figure()\n",
    "    fig.add_trace(go.Scatter(x=data.index, y=data.y_true,\n",
    "                            mode='lines',\n",
    "                            line_color='#333C83', name='y_true'))\n",
    "    \n",
    "    fig.add_trace(go.Scatter(x=data.index, y=data.y_pred,\n",
    "                            mode='lines',\n",
    "                            line_color='red', name='y_pred'))\n",
    "    clr_selection = 'green'\n",
    "    color_switch = lambda x: 'blue' if x != 'blue' else 'green'\n",
    "    \n",
    "    for idx, cp in enumerate(my_bkps):\n",
    "        if cp >= len(data):\n",
    "            break\n",
    "\n",
    "        fig.add_vline(x=data.index[cp], line_width=3, line_dash=\"dash\", line_color=\"red\")\n",
    "\n",
    "        if idx < len(my_bkps) - 2:\n",
    "            clr_selection = color_switch(clr_selection)\n",
    "            fig.add_vrect(x0=data.index[cp], x1=data.index[my_bkps[idx+1]], line_width=0, fillcolor=clr_selection, opacity=0.1)\n",
    "    \n",
    "    fig.update_layout(title=title)\n",
    "    fig.show()\n",
    "    \n",
    "    if plot_metrics:\n",
    "        for roll in [24, 24*7]:\n",
    "            fig = go.Figure()\n",
    "            fig.add_trace(go.Scatter(x=data.index, y=df_err['SAPE'].rolling(roll).mean(),\n",
    "                                    mode='lines',\n",
    "                                    line_color='#333C83', name=f'SAPE rolling({roll})'))\n",
    "\n",
    "            for idx, cp in enumerate(my_bkps):\n",
    "                    if cp >= len(data):\n",
    "                        break\n",
    "\n",
    "                    fig.add_vline(x=data.index[cp], line_width=3, line_dash=\"dash\", line_color=\"red\")\n",
    "\n",
    "            fig.update_layout(title=f'SAPE rolling({roll})')\n",
    "            fig.show()\n",
    "\n",
    "        for x in reversed(['SAPE']):\n",
    "            fig = go.Figure()\n",
    "            fig.add_trace(go.Scatter(x=data.index, y=df_err[x],\n",
    "                                    mode='lines',\n",
    "                                    line_color='#333C83', name=x))\n",
    "\n",
    "            for idx, cp in enumerate(my_bkps):\n",
    "                if cp >= len(data):\n",
    "                    break\n",
    "\n",
    "                fig.add_vline(x=data.index[cp], line_width=3, line_dash=\"dash\", line_color=\"red\")\n",
    "            fig.update_layout(title=x)\n",
    "            fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "plot_pred_bkps(df_forecast_res, my_bkps, '2013-01-05 00:00:00')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "plot_pred_bkps(df_forecast_res, my_bkps, '2014-01-01 00:00:00')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def plot_pred_bkps_simple(data, my_bkps, from_dt=None, to_dt=None, title=None):\n",
    "    my_bkps = [x for x in my_bkps if x < len(data)]\n",
    "    dt_my_bkps = data.index[my_bkps]\n",
    "    if from_dt:\n",
    "        data = data[data.index >= from_dt]\n",
    "        \n",
    "    if to_dt:\n",
    "        data = data[data.index <= to_dt]\n",
    "    \n",
    "    dt_my_bkps = [x for x in dt_my_bkps if x >= pd.to_datetime(from_dt) and x <= pd.to_datetime(to_dt)]\n",
    "        \n",
    "    df_err = data.copy()\n",
    "    df_err.loc[:, 'AE'] = (df_err.y_true - df_err.y_pred).abs()\n",
    "    df_err.loc[:, 'SE'] = (df_err.y_true - df_err.y_pred) ** 2\n",
    "    df_err.loc[:, 'SAPE'] = ((df_err.y_pred - df_err.y_true).abs() / ((df_err.y_true.abs() + df_err.y_pred.abs())/2)) * 100\n",
    "    \n",
    "    fig = go.Figure()\n",
    "    fig.add_trace(go.Scatter(x=data.index, y=data.y_true,\n",
    "                            mode='lines',\n",
    "                            line_color='#333C83', name='y_true'))\n",
    "    \n",
    "    fig.add_trace(go.Scatter(x=data.index, y=data.y_pred,\n",
    "                            mode='lines',\n",
    "                            line_color='red', name='y_pred'))\n",
    "    clr_selection = 'green'\n",
    "    color_switch = lambda x: 'blue' if x != 'blue' else 'green'\n",
    "    \n",
    "    \n",
    "    \n",
    "    for idx, cp in enumerate(dt_my_bkps):\n",
    "        if cp >= data.index[-1]:\n",
    "            break\n",
    "\n",
    "        fig.add_vline(x=cp, line_width=3, line_dash=\"dash\", line_color=\"red\")\n",
    "\n",
    "        if idx < len(dt_my_bkps) - 2:\n",
    "            clr_selection = color_switch(clr_selection)\n",
    "            fig.add_vrect(x0=cp, x1=dt_my_bkps[idx+1], line_width=0, fillcolor=clr_selection, opacity=0.1)\n",
    "    \n",
    "    fig.update_layout(title=title)\n",
    "    fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "plot_pred_bkps_simple(df_forecast_res, my_bkps, '2013-01-05 00:00:00', '2013-12-30 00:00:00')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "plot_pred_bkps_simple(df_forecast_res, my_bkps, '2014-01-05 00:00:00', '2014-12-30 00:00:00')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "plot_pred_bkps_simple(df_forecast_res, my_bkps, '2019-01-05 00:00:00', '2019-12-30 00:00:00')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.0rc1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}