{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "import torch\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def masked_mse(preds, labels, null_val):\n",
    "    if torch.isnan(null_val):\n",
    "        mask = ~torch.isnan(labels)\n",
    "    else:\n",
    "        mask = (labels != null_val)\n",
    "    mask = mask.float()\n",
    "    mask /= torch.mean((mask))\n",
    "    mask = torch.where(torch.isnan(mask), torch.zeros_like(mask), mask)\n",
    "    loss = (preds - labels)**2\n",
    "    loss = loss * mask\n",
    "    loss = torch.where(torch.isnan(loss), torch.zeros_like(loss), loss)\n",
    "    return torch.mean(loss)\n",
    "\n",
    "\n",
    "def masked_rmse(preds, labels, null_val):\n",
    "    return torch.sqrt(masked_mse(preds=preds, labels=labels, null_val=null_val))\n",
    "\n",
    "\n",
    "def masked_mae(preds, labels, null_val):\n",
    "    if torch.isnan(null_val):\n",
    "        mask = ~torch.isnan(labels)\n",
    "    else:\n",
    "        mask = (labels != null_val)\n",
    "    mask = mask.float()\n",
    "    mask /= torch.mean((mask))\n",
    "    mask = torch.where(torch.isnan(mask), torch.zeros_like(mask), mask)\n",
    "    loss = torch.abs(preds - labels)\n",
    "    loss = loss * mask\n",
    "    loss = torch.where(torch.isnan(loss), torch.zeros_like(loss), loss)\n",
    "    return torch.mean(loss)\n",
    "\n",
    "\n",
    "def masked_mape(preds, labels, null_val):\n",
    "    if torch.isnan(null_val):\n",
    "        mask = ~torch.isnan(labels)\n",
    "    else:\n",
    "        mask = (labels != null_val)\n",
    "    mask = mask.float()\n",
    "    mask /= torch.mean((mask))\n",
    "    mask = torch.where(torch.isnan(mask), torch.zeros_like(mask), mask)\n",
    "    loss = torch.abs(preds - labels) / labels\n",
    "    loss = loss * mask\n",
    "    loss = torch.where(torch.isnan(loss), torch.zeros_like(loss), loss)\n",
    "    return torch.mean(loss)\n",
    "\n",
    "\n",
    "def compute_all_metrics(preds, labels, null_val):\n",
    "    mae = masked_mae(preds, labels, null_val).item()\n",
    "    mape = masked_mape(preds, labels, null_val).item()\n",
    "    rmse = masked_rmse(preds, labels, null_val).item()\n",
    "    return mae, mape, rmse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "datasets_list = ['pems03_flow', 'pems04_flow', 'pems07_flow', 'pems08_flow', 'occpairs_occupancy', 'occhamburg_occupancy', 'pemsbay_speed', 'metrla_speed', 'trafficsh_speed', 'bikenyc_inflow', 'taxinyc_inflow', 'tdrive_inflow']\n",
    "folder_path = \"/data/weichen/ST-Library/datasets/eval_datasets\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for few_shot_ratio in [0.1, 1.0]:\n",
    "    print('-'*150)\n",
    "    if few_shot_ratio == 0.1:\n",
    "        print(f\"\\t\\t\\t\\t\\t\\t eval_shot: Few-shot\")\n",
    "    else:\n",
    "        print(f\"\\t\\t\\t\\t\\t\\t eval_shot: Full-shot\")\n",
    "    print('-'*150)\n",
    "    for dataset in datasets_list:\n",
    "        \n",
    "        print('*'*30)\n",
    "        print(f\"Dataset: {dataset}\")\n",
    "        print('*'*30)\n",
    "        \n",
    "        for num_steps in [12, 24]:\n",
    "        \n",
    "            with open(f\"{folder_path}/{dataset}/{dataset}_temporal.pkl\", 'rb') as f:\n",
    "                df = pickle.load(f)\n",
    "                raw_temporal_data = torch.tensor(df.values).unsqueeze(-1)\n",
    "                f.close()\n",
    "\n",
    "            T, N, _ = raw_temporal_data.shape\n",
    "\n",
    "            # Add time-based features if specified\n",
    "            feature_list = [raw_temporal_data]\n",
    "\n",
    "            # add_time_of_day\n",
    "            time_ind = (df.index.values - df.index.values.astype('datetime64[D]')) / np.timedelta64(1, 'D') * 288\n",
    "            time_of_day = np.tile(time_ind, [1, N, 1]).transpose((2, 1, 0))\n",
    "            feature_list.append(torch.tensor(time_of_day, dtype=torch.float32))\n",
    "\n",
    "            # add_day_of_week:\n",
    "            dow = df.index.dayofweek\n",
    "            dow_tiled = np.tile(dow, [1, N, 1]).transpose((2, 1, 0))\n",
    "            day_of_week = dow_tiled / 7 * 7\n",
    "            feature_list.append(torch.tensor(day_of_week, dtype=torch.float32))\n",
    "\n",
    "            temporal_data = torch.cat(feature_list, dim=-1).numpy()  # Concatenate features along the channel dimension\n",
    "\n",
    "            # train_rate = few_shot_ratio if few_shot_ratio <= train_val_test_rate[0] else train_val_test_rate[0]\n",
    "            train_rate = 0.6 * few_shot_ratio\n",
    "            valid_rate = 0.2\n",
    "            test_rate = 0.2\n",
    "\n",
    "            train = temporal_data[:int(T * train_rate)]\n",
    "            test = temporal_data[int(T * (1 - test_rate)):]\n",
    "            \n",
    "            # Create a dictionary to store lists of observations for each (tod, dow) pair\n",
    "            history = {}\n",
    "            # Iterate through the historical data to populate the history dictionary\n",
    "            for i in range(train.shape[0]-num_steps-1):\n",
    "                \n",
    "                key = (train[i, 0, 1], train[i, 0, 2])  # (tod, dow) tuple\n",
    "                if key not in history:\n",
    "                    history[key] = []\n",
    "                    \n",
    "                # Collect observations for the next num_steps steps\n",
    "                future_values = train[i+1:i+num_steps+1,:,0]\n",
    "                \n",
    "                history[key].append(future_values)  # Collect and store future values\n",
    "            \n",
    "            history_averages = {}\n",
    "\n",
    "            # Calculate the average values for each (tod, dow) pair\n",
    "            for k, v in history.items():\n",
    "                stacked_array = np.stack(v, axis=-1)\n",
    "                averages = np.mean(stacked_array, axis=-1)\n",
    "                history_averages[k] = averages\n",
    "            \n",
    "            \n",
    "            preds = []\n",
    "            labels = []\n",
    "\n",
    "            # Retrieve labels and predictions\n",
    "            for i in range(test.shape[0]-num_steps-1):\n",
    "\n",
    "                key = (test[i, 0, 1], test[i, 0, 2])  # (tod, dow) tuple\n",
    "                \n",
    "                labels.append(test[i+1:i+num_steps+1,:,0])\n",
    "                \n",
    "                try:\n",
    "                    preds.append(history_averages[key])\n",
    "                except KeyError:\n",
    "                    # If the (tod, dow) pair is not present in the history dictionary, predict last point\n",
    "                    preds.append(torch.tensor(test[i,:,0]).expand(num_steps, -1))\n",
    "                \n",
    "            labels = np.stack(labels, axis=0)\n",
    "            preds = np.stack(preds, axis=0)\n",
    "            \n",
    "            labels = torch.Tensor(labels)\n",
    "            preds = torch.Tensor(preds)\n",
    "\n",
    "            # handle the precision issue when performing inverse transform to label\n",
    "            mask_value = torch.tensor(0)\n",
    "\n",
    "            test_mae = []\n",
    "            test_mape = []\n",
    "            test_rmse = []\n",
    "\n",
    "            # Calculate metrics\n",
    "            for i in range(12):\n",
    "                res = compute_all_metrics(preds[:,i,:], labels[:,i,:], mask_value)\n",
    "                test_mae.append(res[0])\n",
    "                test_mape.append(res[1] * 100)\n",
    "                test_rmse.append(res[2])\n",
    "\n",
    "            mae_mean = np.mean(test_mae)\n",
    "            mae_std = 0\n",
    "            rmse_mean = np.mean(test_rmse)\n",
    "            rmse_std = 0\n",
    "            mape_mean = np.mean(test_mape)\n",
    "            mape_std = 0\n",
    "            \n",
    "            if num_steps == 12:\n",
    "                print('HA - Short Forecasting' + \"\\t\\t MAE:\" + \"& $\" + f\"{mae_mean:.2f}\" + \"\\\\textcolor{gray}{\\\\text{\\scriptsize±\" + f'{mae_std:.2f}'+\"}}$\" + \"\\t\\t RMSE:\" + \"& $\" + f\"{rmse_mean:.2f}\" + \"\\\\textcolor{gray}{\\\\text{\\scriptsize±\" + f'{rmse_std:.2f}'+\"}}$\" + \"\\t\\t MAPE:\" + \"& $\" + f\"{mape_mean:.2f}\" + \"\\\\textcolor{gray}{\\\\text{\\scriptsize±\" + f'{mape_std:.2f}'+\"}}$\")\n",
    "            else:\n",
    "                print('HA - Long Forecasting' + \"\\t\\t MAE:\" + \"& $\" + f\"{mae_mean:.2f}\" + \"\\\\textcolor{gray}{\\\\text{\\scriptsize±\" + f'{mae_std:.2f}'+\"}}$\" + \"\\t\\t RMSE:\" + \"& $\" + f\"{rmse_mean:.2f}\" + \"\\\\textcolor{gray}{\\\\text{\\scriptsize±\" + f'{rmse_std:.2f}'+\"}}$\" + \"\\t\\t MAPE:\" + \"& $\" + f\"{mape_mean:.2f}\" + \"\\\\textcolor{gray}{\\\\text{\\scriptsize±\" + f'{mape_std:.2f}'+\"}}$\")"
   ]
  }
 ],
 "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.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}