T-DPnet Malaysia load forecasting.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "dfd3aad7-a3e6-495e-abe9-c942ff650b0e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch import nn\n",
    "import torch.nn.functional as F \n",
    "from torch.optim import Adam\n",
    "\n",
    "import numpy as np\n",
    "import os\n",
    "import random\n",
    "import matplotlib.pyplot as plt\n",
    "import pickle\n",
    "from tqdm import tqdm\n",
    "import pandas as pd\n",
    "import util\n",
    "from sklearn.preprocessing import StandardScaler, MinMaxScaler\n",
    "from time import time\n",
    "import argparse\n",
    "from datetime import date\n",
    "from progressbar import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ff69121e-b586-4426-aed4-28e451e28f3f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import warnings                                  # `do not disturbe` mode\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "import numpy as np                               # vectors and matrices\n",
    "import pandas as pd                              # tables and data manipulations\n",
    "import matplotlib.pyplot as plt                  # plots\n",
    "                         # more plots\n",
    "\n",
    "from dateutil.relativedelta import relativedelta # working with dates with style\n",
    "from scipy.optimize import minimize              # for function minimization\n",
    "\n",
    "import statsmodels.formula.api as smf            # statistics and econometrics\n",
    "import statsmodels.tsa.api as smt\n",
    "import statsmodels.api as sm\n",
    "import scipy.stats as scs\n",
    "from statsmodels.tsa.seasonal import seasonal_decompose\n",
    "\n",
    "from itertools import product                    # some useful functions\n",
    "from tqdm import tqdm_notebook\n",
    "\n",
    "import seaborn as sns\n",
    "np.random.seed(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1107d31d-c9f3-4d1e-b44f-2b98b15cb226",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Backbone(nn.Module):\n",
    "\n",
    "    def __init__(self, global_hidden_size, n_global_factors, num_layers):\n",
    "        super(Backbone, self).__init__()\n",
    "        self.transformer = TransAm(global_hidden_size)\n",
    "        self.factor = nn.Linear(global_hidden_size, n_global_factors)\n",
    "\n",
    "    def forward(self, X):\n",
    "        num_ts, num_features = X.shape\n",
    "        X = X.unsqueeze(1)\n",
    "        ht = self.transformer(X)\n",
    "        ht = F.relu(ht)\n",
    "        gt = ht\n",
    "        return gt.view(num_ts, -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "507968e8-dd25-4907-b0a9-9e1393cdabab",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Noise(nn.Module):\n",
    "\n",
    "    def __init__(self, noise_hidden_size, num_layers):\n",
    "        super(Noise, self).__init__()\n",
    "        self.transformer = TransAm(noise_hidden_size, num_layers)\n",
    "        self.affine = nn.Linear(noise_hidden_size, 1)\n",
    "\n",
    "    def forward(self, X):\n",
    "        num_ts, num_features = X.shape\n",
    "        X = X.unsqueeze(1)\n",
    "        ht = self.transformer(X)\n",
    "        ht = F.relu(ht)\n",
    "        sigma_t = self.affine(ht)\n",
    "        sigma_t = torch.log(1 + torch.exp(sigma_t))\n",
    "        return sigma_t.view(-1, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "88155b4b-0285-4cb0-af30-53b4d2124a8f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class TDPnet(nn.Module):\n",
    "\n",
    "    def __init__(self, noise_hidden_size, global_hidden_size, n_global_factors, num_layers):\n",
    "        super(TDPnet, self).__init__()\n",
    "        self.noise = Noise(noise_hidden_size, num_layers)\n",
    "        self.global_factor = Backbone(global_hidden_size, n_global_factors, num_layers)\n",
    "        self.embed = nn.Linear(global_hidden_size, n_global_factors)\n",
    "    \n",
    "    def forward(self, X,):\n",
    "        if isinstance(X, type(np.empty(2))):\n",
    "            X = torch.from_numpy(X).float()\n",
    "        num_ts, num_periods, num_features = X.size()\n",
    "        mu = []\n",
    "        sigma = []\n",
    "        for t in range(num_periods):\n",
    "            gt = self.global_factor(X[:, t, :])\n",
    "            ft = self.embed(gt)\n",
    "            ft = ft.sum(dim=1).view(-1, 1)\n",
    "            sigma_t = self.noise(X[:, t, :])\n",
    "            mu.append(ft)\n",
    "            sigma.append(sigma_t)\n",
    "        mu = torch.cat(mu, dim=1).view(num_ts, num_periods)\n",
    "        sigma = torch.cat(sigma, dim=1).view(num_ts, num_periods) + 1e-6\n",
    "        return mu, sigma\n",
    "    \n",
    "    def sample(self, X, num_samples=100):\n",
    "        if isinstance(X, type(np.empty(2))):\n",
    "            X = torch.from_numpy(X).float()\n",
    "        mu, var = self.forward(X)\n",
    "        num_ts, num_periods = mu.size()\n",
    "        z = torch.zeros(num_ts, num_periods)\n",
    "        for _ in range(num_samples):\n",
    "            dist = torch.distributions.normal.Normal(loc=mu, scale=var)\n",
    "            zs = dist.sample().view(num_ts, num_periods)\n",
    "            z += zs\n",
    "        z = z / num_samples\n",
    "        return z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "be5d06fc-16c3-42d7-9c0e-59510255593d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def batch_generator(X, y, num_obs_to_train, seq_len, batch_size):\n",
    "    '''\n",
    "    Args:\n",
    "    X (array like): shape (num_samples, num_features, num_periods)\n",
    "    y (array like): shape (num_samples, num_periods)\n",
    "    num_obs_to_train (int):\n",
    "    seq_len (int): sequence/encoder/decoder length\n",
    "    batch_size (int)\n",
    "    '''\n",
    "    num_ts, num_periods, _ = X.shape\n",
    "    if num_ts < batch_size:\n",
    "        batch_size = num_ts\n",
    "    t = random.choice(range(num_obs_to_train, num_periods-seq_len))\n",
    "    batch = random.sample(range(num_ts), batch_size)\n",
    "    X_train_batch = X[batch, t-num_obs_to_train:t, :]\n",
    "    y_train_batch = y[batch, t-num_obs_to_train:t]\n",
    "    Xf = X[batch, t:t+seq_len]\n",
    "    yf = y[batch, t:t+seq_len]\n",
    "    return X_train_batch, y_train_batch, Xf, yf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "9a268ea8-719e-4703-a894-16b8ae608640",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(\n",
    "    X, \n",
    "    y,\n",
    "    args\n",
    "    ):\n",
    "    '''\n",
    "    Args:\n",
    "    - X (array like): shape (num_samples, num_features, num_periods)\n",
    "    - y (array like): shape (num_samples, num_periods)\n",
    "    - epoches (int): number of epoches to run\n",
    "    - step_per_epoch (int): steps per epoch to run\n",
    "    - seq_len (int): output horizon\n",
    "    - likelihood (str): what type of likelihood to use, default is gaussian\n",
    "    - num_skus_to_show (int): how many skus to show in test phase\n",
    "    - num_results_to_sample (int): how many samples in test phase as prediction\n",
    "    '''\n",
    "    # rho = args.quantile\n",
    "    num_ts, num_periods, num_features = X.shape\n",
    "    model = TDPnet(\n",
    "        args[\"noise_hidden_size\"],args[\"global_hidden_size\"], args[\"n_factors\"], args[\"Transformerheads\"])\n",
    "    optimizer = Adam(model.parameters(), lr=args[\"lr\"])\n",
    "\n",
    "    random.seed(2)\n",
    "    # select sku with most top n quantities \n",
    "    Xtr, ytr, Xte, yte = util.train_test_split(X, y)\n",
    "    losses = []\n",
    "    cnt = 0\n",
    "\n",
    "    yscaler = None\n",
    "    if args[\"standard_scaler\"]:\n",
    "        yscaler = util.StandardScaler()\n",
    "    elif args[\"log_scaler\"]:\n",
    "        yscaler = util.LogScaler()\n",
    "    elif args[\"mean_scaler\"]:\n",
    "        yscaler = util.MeanScaler()\n",
    "    if yscaler is not None:\n",
    "        ytr = yscaler.fit_transform(ytr)\n",
    "\n",
    "    # training\n",
    "    progress = ProgressBar()\n",
    "    seq_len = args[\"seq_len\"]\n",
    "    num_obs_to_train = args[\"num_obs_to_train\"]\n",
    "    for epoch in progress(range(args[\"num_epoches\"])):\n",
    "        for step in range(args[\"step_per_epoch\"]):\n",
    "            Xtrain, ytrain, Xf, yf = batch_generator(Xtr, ytr, num_obs_to_train, \n",
    "                        seq_len, args[\"batch_size\"])\n",
    "            Xtrain_tensor = torch.from_numpy(Xtrain).float()\n",
    "            ytrain_tensor = torch.from_numpy(ytrain).float()\n",
    "            Xf = torch.from_numpy(Xf).float()  \n",
    "            yf = torch.from_numpy(yf).float()\n",
    "            mu, sigma = model(Xtrain_tensor)\n",
    "            loss = util.gaussian_likelihood_loss(ytrain_tensor, mu, sigma)\n",
    "            losses.append(loss.item())\n",
    "            optimizer.zero_grad()\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            cnt += 1\n",
    "            \n",
    "    \n",
    "    # test \n",
    "    mape_list = []\n",
    "    # select skus with most top K\n",
    "    X_test = Xte[:, -seq_len-num_obs_to_train:-seq_len, :].reshape((num_ts, -1, num_features))\n",
    "    Xf_test = Xte[:, -seq_len:, :].reshape((num_ts, -1, num_features))\n",
    "    y_test = yte[:, -seq_len-num_obs_to_train:-seq_len].reshape((num_ts, -1))\n",
    "    yf_test = yte[:, -seq_len:].reshape((num_ts, -1))\n",
    "    if yscaler is not None:\n",
    "        y_test = yscaler.transform(y_test)\n",
    "    \n",
    "    result = []\n",
    "    n_samples = args[\"sample_size\"]\n",
    "    for _ in tqdm(range(n_samples)):\n",
    "        y_pred = model.sample(Xf_test)\n",
    "        y_pred = y_pred.data.numpy()\n",
    "        if yscaler is not None:\n",
    "            y_pred = yscaler.inverse_transform(y_pred)\n",
    "        result.append(y_pred.reshape((-1, 1)))\n",
    "    \n",
    "    \n",
    "    result = np.concatenate(result, axis=1)\n",
    "    p50 = np.quantile(result, 0.5, axis=1)\n",
    "    p90 = np.quantile(result, 0.9, axis=1)\n",
    "    p10 = np.quantile(result, 0.1, axis=1)\n",
    "    print(\"p50 {}\".format(p50))\n",
    "\n",
    "    mape = util.MAPE(yf_test, p50)\n",
    "    print(\"P50 MAPE: {}\".format(mape))\n",
    "    mape_list.append(mape)\n",
    "\n",
    "    if args[\"show_plot\"]:\n",
    "        plt.figure(1, figsize=(20, 5))\n",
    "        plt.plot([k + seq_len + num_obs_to_train - seq_len \\\n",
    "            for k in range(seq_len)], p50, \"r-\")\n",
    "        plt.fill_between(x=[k + seq_len + num_obs_to_train - seq_len for k in range(seq_len)], \\\n",
    "            y1=p10, y2=p90, alpha=0.5)\n",
    "        plt.title('Prediction uncertainty')\n",
    "        yplot = yte[-1, -seq_len-num_obs_to_train:]\n",
    "        plt.plot(range(len(yplot)), yplot, \"k-\")\n",
    "        plt.legend([\"P50 forecast\", \"true\", \"P10-P90 quantile\"], loc=\"upper left\")\n",
    "        ymin, ymax = plt.ylim()\n",
    "        plt.vlines(seq_len + num_obs_to_train - seq_len, ymin, ymax, color=\"blue\", linestyles=\"dashed\", linewidth=2)\n",
    "        plt.ylim(ymin, ymax)\n",
    "        plt.xlabel(\"Periods\")\n",
    "        plt.ylabel(\"Y\")\n",
    "        plt.show()\n",
    "    return losses, mape_list, yscaler, model, Xte, yte "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "52c62ade-0c29-4bd2-86d0-d7d1aab9c494",
   "metadata": {},
   "outputs": [],
   "source": [
    "args = {\n",
    "\"num_epoches\":150,\n",
    "\"step_per_epoch\": 3,\n",
    "\"lr\":0.005,\n",
    "'Transformerheads': 2,\n",
    "'global_hidden_size': 10,\n",
    "'noise_hidden_size': 10,\n",
    "'n_factors': 10,\n",
    "\"likelihood\":\"g\",\n",
    "\"seq_len\":24,\n",
    "\"num_obs_to_train\":24*7,\n",
    "\"num_results_to_sample\":1,\n",
    "\"show_plot\":True,\n",
    "\"run_test\":True,\n",
    "\"standard_scaler\":False,\n",
    "\"log_scaler\":False,\n",
    "\"mean_scaler\":True,\n",
    "\"batch_size\":64,\n",
    "\"sample_size\":20,\n",
    "}\n",
    "\n",
    "num_obs_to_train=24*7\n",
    "seq_len = 24"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "850f4cb1-0220-49e4-b90f-387e103d3197",
   "metadata": {},
   "source": [
    "## Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "9ac92f21-6855-4e5d-a62a-7b1450fcd732",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_csv(\"../../data/malysia_cleaned.csv\", parse_dates=[\"date\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "73c8480c-a31a-46f6-ada5-531b19b2a3b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import MinMaxScaler\n",
    "scaler = MinMaxScaler(feature_range=(0, 1))\n",
    "scaler.fit(np.array(data.load).reshape(-1, 1))\n",
    "scaled_data= scaler.transform(np.array(data.load).reshape(-1, 1))\n",
    "data['load'] = np.array(scaled_data).reshape(1, -1)[0]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "6f144e2c-f3bb-48cc-a854-95a848313474",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from pandas import Series\n",
    "from matplotlib import pyplot\n",
    "pyplot.figure(1)\n",
    "pyplot.subplot(211)\n",
    "data.load.hist()\n",
    "pyplot.subplot(212)\n",
    "data.load.plot(kind='kde')\n",
    "pyplot.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "c95f504c-e1cd-47c3-84f3-51f9f1081739",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>date</th>\n",
       "      <th>load</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2009-01-01 01:00:00</td>\n",
       "      <td>0.226203</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2009-01-01 02:00:00</td>\n",
       "      <td>0.203901</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2009-01-01 03:00:00</td>\n",
       "      <td>0.184117</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2009-01-01 04:00:00</td>\n",
       "      <td>0.183099</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2009-01-01 05:00:00</td>\n",
       "      <td>0.177528</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 date      load\n",
       "0 2009-01-01 01:00:00  0.226203\n",
       "1 2009-01-01 02:00:00  0.203901\n",
       "2 2009-01-01 03:00:00  0.184117\n",
       "3 2009-01-01 04:00:00  0.183099\n",
       "4 2009-01-01 05:00:00  0.177528"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.head(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "196fef91-5eda-483b-a795-dcc6cfd2d471",
   "metadata": {},
   "outputs": [],
   "source": [
    "data[\"year\"] = data[\"date\"].apply(lambda x: x.year)\n",
    "data[\"day_of_week\"] = data[\"date\"].apply(lambda x: x.dayofweek)\n",
    "data[\"hour\"] = data[\"date\"].apply(lambda x: x.hour)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "575aa9a1-b4ef-4da3-b755-0ada9c52f91c",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.set_index(pd.to_datetime(data['date']), inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "ae5fc7c5-ea9d-45c4-baaf-c8a5d70c9187",
   "metadata": {},
   "outputs": [],
   "source": [
    "import holidays\n",
    "\n",
    "de_holidays = holidays.Malaysia()\n",
    "cet_dates = pd.Series(data.index, index=data.index)\n",
    "data[\"holiday\"] = cet_dates.apply(lambda d: d in de_holidays)\n",
    "data[\"holiday\"] = data[\"holiday\"].astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "1959c714-8d2c-4824-bd0c-7b99133df5ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "#lags\n",
    "counter = np.arange(1,25)\n",
    "lags=[24, 25, 47,48,49,71,72]\n",
    "lag_cols = [f\"conso_lag_{cn}\" for cn in lags ]\n",
    "for lag, lag_col in zip(lags, lag_cols):\n",
    "    data[lag_col] = data[\"load\"].shift(lag)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "4d095bbd-0c17-4969-b460-af087c4512da",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.dropna(inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "fb806a8e-e33f-4806-ab4f-f0a40ed1632e",
   "metadata": {},
   "outputs": [],
   "source": [
    "features = [\"hour\", \"day_of_week\",\"holiday\"]\n",
    "hours = data[\"hour\"]\n",
    "dows = data[\"day_of_week\"]\n",
    "holidays = data[\"holiday\"]\n",
    "lags = data[lag_cols]\n",
    "X = np.c_[np.asarray(hours), np.asarray(dows), np.asarray(holidays), np.asarray(lags)]\n",
    "num_features = X.shape[1]\n",
    "num_periods = len(data)\n",
    "X = np.asarray(X).reshape((-1, num_periods, num_features))\n",
    "y = np.asarray(data[\"load\"]).reshape((-1, num_periods))\n",
    "quantiles = [0.1, 0.5, 0.9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "76a89cba-3902-4dab-a4da-9dc8113e36bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "feature_size = X.shape[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "07ee0605-5b51-4162-b8f8-1bb31d177e11",
   "metadata": {},
   "outputs": [],
   "source": [
    "class TransAm(nn.Module):\n",
    "    def __init__(self,global_hidden_size, num_layers=1,feature_size=feature_size,dropout=0.2):\n",
    "        super(TransAm, self).__init__()\n",
    "        self.model_type = 'Transformer'\n",
    "        \n",
    "        self.src_mask = None\n",
    "        # self.pos_encoder = PositionalEncoding(feature_size)\n",
    "        self.encoder_layer = nn.TransformerEncoderLayer(d_model=feature_size, nhead=feature_size, dropout=dropout)\n",
    "        ### how many encoder layers you want\n",
    "        self.transformer_encoder = nn.TransformerEncoder(self.encoder_layer, num_layers=num_layers)\n",
    "        ### decoder \n",
    "        self.decoder = nn.Linear(feature_size, global_hidden_size)\n",
    "        self.init_weights()\n",
    "\n",
    "    def init_weights(self):\n",
    "        initrange = 0.1    \n",
    "        self.decoder.bias.data.zero_()\n",
    "        self.decoder.weight.data.uniform_(-initrange, initrange)\n",
    "\n",
    "    def forward(self,src):\n",
    "        if self.src_mask is None or self.src_mask.size(0) != len(src):\n",
    "            device = src.device\n",
    "            mask = self._generate_square_subsequent_mask(len(src)).to(device)\n",
    "            self.src_mask = mask\n",
    "\n",
    "        output = self.transformer_encoder(src,self.src_mask)\n",
    "        output = self.decoder(output)\n",
    "        return output\n",
    "\n",
    "    def _generate_square_subsequent_mask(self, sz):\n",
    "        mask = (torch.triu(torch.ones(sz, sz)) == 1).transpose(0, 1)\n",
    "        mask = mask.float().masked_fill(mask == 0, float('-inf')).masked_fill(mask == 1, float(0.0))\n",
    "        return mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "795ef5a2-e215-417e-9b7f-e715ef9ccb58",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100% |########################################################################|\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████| 20/20 [00:02<00:00,  9.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p50 [0.2008803  0.1849809  0.16918263 0.17222502 0.18418107 0.19283904\n",
      " 0.20520744 0.30076617 0.48529108 0.66971993 0.78405562 0.78692496\n",
      " 0.79833424 0.77653545 0.80925736 0.80236587 0.71298072 0.66135964\n",
      " 0.62085062 0.6397191  0.56930208 0.48039889 0.39209808 0.20172357]\n",
      "P50 MAPE: 0.19503378022651005\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1440x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "losses, mape_list, yscaler, model, Xte, yte  = train(X, y, args)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "5c4536d6-0791-44c6-928b-f6b3f105feab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(range(len(losses)), losses, \"k-\")\n",
    "plt.xlabel(\"Period\")\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "88fa119f-8aab-42ae-a61e-22846baba637",
   "metadata": {},
   "outputs": [],
   "source": [
    "num_ts, _, num_features = Xte.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "c779fedf-224f-49e3-b879-31f1fdb0d555",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████████| 30/30 [01:00<00:00,  2.03s/it]\n"
     ]
    }
   ],
   "source": [
    "# test\n",
    "\n",
    "p50_list=[]\n",
    "p90_list=[]\n",
    "p10_list=[]\n",
    "true_values=[]\n",
    "x_test_list = []\n",
    "pp = (Xte.shape[1]) //seq_len\n",
    "for k in tqdm(range(pp)):\n",
    "    \n",
    "    mape_list = []\n",
    "    Xf_test = Xte[:, seq_len*k:seq_len*(k+1), :].reshape((num_ts, -1, num_features))\n",
    "    yf_test = yte[:, seq_len*k:seq_len*(k+1)].reshape((num_ts, -1))\n",
    "    \n",
    "    \n",
    "    result = []\n",
    "    n_samples = args[\"sample_size\"]\n",
    "    for _ in range(n_samples):\n",
    "        y_pred = model.sample(Xf_test)\n",
    "        y_pred = y_pred.data.numpy()\n",
    "        if yscaler is not None:\n",
    "            y_pred = yscaler.inverse_transform(y_pred)\n",
    "        result.append(y_pred.reshape((-1, 1)))\n",
    "    \n",
    "    result = np.concatenate(result, axis=1)\n",
    "    p50 = np.quantile(result, 0.5, axis=1)\n",
    "    p90 = np.quantile(result, 0.9, axis=1)\n",
    "    p10 = np.quantile(result, 0.1, axis=1)\n",
    "    \n",
    "    \n",
    "    p50_list.append(p50)\n",
    "    p90_list.append(p90)\n",
    "    p10_list.append(p10)\n",
    "    true_values.append(yf_test[0])\n",
    "    x_test_list.append(Xf_test)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "7c85183b-e847-49a7-a7ab-3a8276d0ea26",
   "metadata": {},
   "outputs": [],
   "source": [
    "p90_list= np.array(p90_list).flatten()\n",
    "p50_list= np.array(p50_list).flatten()\n",
    "p10_list= np.array(p10_list).flatten()\n",
    "true_values= np.array(true_values).flatten()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "485fc182-85cc-4338-8277-a68dcf72947f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MAE: 0.07728740473099581, RMSE: 0.09767838818778148, MAPE: 0.14961148278791322\n",
      "The accuracy of the model is: 0.870177\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import r2_score, median_absolute_error, mean_absolute_error, mean_squared_error, mean_absolute_percentage_error\n",
    "print(f\"MAE: {mean_absolute_error(true_values, p50_list)}, RMSE: {mean_squared_error(true_values, p50_list) ** 0.5}, MAPE: {mean_absolute_percentage_error(true_values, p50_list)}\")\n",
    "print( \"The accuracy of the model is: %f\" %r2_score(true_values, p50_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "d3c44ab0-1333-4f02-83a6-a9c6a4ac00b6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(1, figsize=(6,5))\n",
    "plt.plot(p50_list[0:168])\n",
    "plt.plot(true_values[0:168])\n",
    "plt.fill_between(x=np.arange(168), y1=p10_list[0:168], y2=p90_list[0:168], alpha=0.5)\n",
    "plt.title('Malaysia 24-hours Prediction')\n",
    "plt.legend([\"P50 forecast\", \"true\", \"P10-P90 quantile\"], loc=\"upper right\")\n",
    "ymin, ymax = plt.ylim()\n",
    "plt.xlabel('Time(h)')\n",
    "plt.ylabel('Load consumption (Mhw)')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "541c77f3-cfac-406e-a250-01ed29ef3684",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a1d985f6-4d5e-4e53-bba6-f289b4c287da",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e271e4d-70cc-4ddf-9f2c-a87721a18f66",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6dddcec4-8d9b-4511-834f-ffd79661ec77",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fd22c1ba-f5f9-4351-b4dc-9bac5b300552",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}