{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Different Prediction Horizons in Chesapeake Bay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import h5py\n",
    "import scipy\n",
    "import numpy as np\n",
    "import torch\n",
    "import os\n",
    "import sys\n",
    "from dataset.dataset_prediction import PRE8dDataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load(path):\n",
    "    path = path + \"/with_imputation\"\n",
    "    preds = []\n",
    "    for i in range(10):\n",
    "        preds.append(np.load(path+\"/prediction_{}.npy\".format(i)))\n",
    "    return np.stack(preds, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "category = []\n",
    "pred_len = []\n",
    "mse_list = []\n",
    "mae_list = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**predictions for 1 year (PRE)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import argparse\n",
    "from torch.utils.data import DataLoader\n",
    "\n",
    "parser = argparse.ArgumentParser(description='Prediction')\n",
    "parser.add_argument('--area', type=str, default='Chesapeake', help='which bay area we focus')\n",
    "parser.add_argument('--method', type=str, default='GraphTransformer', help='which bay area we focus')\n",
    "parser.add_argument('--index', type=int, default=0, help='which dataset we use')\n",
    "\n",
    "parser.add_argument('--epochs', type=int, default=200, help='epochs')\n",
    "parser.add_argument('--batch_size', type=int, default=8, help='batch size')\n",
    "parser.add_argument('--lr', type=float, default=1e-4, help='learning rate')\n",
    "parser.add_argument('--wd', type=float, default=1e-6, help='weight decay')\n",
    "parser.add_argument('--test_freq', type=int, default=20, help='test per n epochs')\n",
    "parser.add_argument('--hidden_dim', type=int, default=8)\n",
    "\n",
    "parser.add_argument('--in_len', type=int, default=46)\n",
    "parser.add_argument('--out_len', type=int, default=46)\n",
    "parser.add_argument('--missing_ratio', type=float, default=0.1)\n",
    "\n",
    "config = parser.parse_args([])\n",
    "test_dloader = DataLoader(PRE8dDataset(config, mode='test'), config.batch_size, shuffle=False)\n",
    "\n",
    "labels_list = []\n",
    "label_masks_list = []\n",
    "\n",
    "for test_step, (datas, data_ob_masks, data_gt_masks, labels, label_masks) in enumerate(test_dloader):\n",
    "    labels_list.append(labels[:,:,0])\n",
    "    label_masks_list.append(label_masks[:,:,0])\n",
    "\n",
    "labels = torch.cat(labels_list, 0)\n",
    "label_masks = torch.cat(label_masks_list, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "base_dir = \"./log/prediction_46_46/{}/\".format(config.area)\n",
    "prediction_xg = np.load(base_dir+\"XGBoost/without_imputation/prediction_0.npy\", allow_pickle=True)\n",
    "prediction_our = load(base_dir+\"STIMP\")\n",
    "prediction_mtgnn = np.load(base_dir+\"MTGNN/without_imputation/prediction_0.npy\", allow_pickle=True)\n",
    "prediction_tsmixer = np.load(base_dir+\"TSMixer/without_imputation/prediction_0.npy\", allow_pickle=True)\n",
    "prediction_crossformer = np.load(base_dir+\"CrossFormer/without_imputation/prediction_0.npy\", allow_pickle=True)\n",
    "prediction_iTransformer = np.load(base_dir+\"iTransformer/without_imputation/prediction_0.npy\", allow_pickle=True)\n",
    "prediction_predrnn = np.load(base_dir+\"PredRNN/without_imputation/prediction_0.npy\", allow_pickle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "label_masks = label_masks.squeeze()\n",
    "labels = labels.squeeze()\n",
    "\n",
    "prediction_our = torch.from_numpy(prediction_our).squeeze()\n",
    "prediction_xg = torch.from_numpy(prediction_xg).squeeze()\n",
    "prediction_tsmixer = torch.from_numpy(prediction_tsmixer).squeeze()\n",
    "prediction_mtgnn = torch.from_numpy(prediction_mtgnn).squeeze()\n",
    "prediction_crossformer = torch.from_numpy(prediction_crossformer).squeeze()\n",
    "prediction_iTransformer = torch.from_numpy(prediction_iTransformer).squeeze()\n",
    "prediction_predrnn = torch.from_numpy(prediction_predrnn).squeeze()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.03125612\n",
      "0.04946128989436908\n",
      "0.051471688\n",
      "0.051311042\n",
      "0.05155146\n",
      "0.052918386\n",
      "0.036253165\n"
     ]
    }
   ],
   "source": [
    "mse_our= (((prediction_our.mean(1)- labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_our))\n",
    "\n",
    "\n",
    "mse_xg = (((prediction_xg- labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_xg))\n",
    "\n",
    "mse_tsmixer = (((prediction_tsmixer - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_tsmixer))\n",
    "\n",
    "mse_crossformer = (((prediction_crossformer - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_crossformer))\n",
    "\n",
    "mse_mtgnn = (((prediction_mtgnn - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_mtgnn))\n",
    "\n",
    "mse_iTransformer = (((prediction_iTransformer - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_iTransformer))\n",
    "\n",
    "mse_predrnn = (((prediction_predrnn - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_predrnn))\n",
    "\n",
    "\n",
    "mse_our[mse_our==0]=np.nan\n",
    "mse_xg[mse_xg==0]=np.nan\n",
    "mse_crossformer[mse_crossformer==0]=np.nan\n",
    "mse_mtgnn[mse_mtgnn==0]=np.nan\n",
    "mse_tsmixer[mse_tsmixer==0]=np.nan\n",
    "mse_iTransformer[mse_iTransformer==0]=np.nan\n",
    "mse_predrnn[mse_predrnn==0]=np.nan\n",
    "\n",
    "\n",
    "category.extend([\"XGBoost\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"one\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"MTGNN\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"one\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"CrossFormer\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"one\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"TSMixer\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"one\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"iTransformer\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"one\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"PredRNN\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"one\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"STIMP\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"one\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "mse_list.extend([mse_xg.numpy(), mse_mtgnn.numpy(), mse_crossformer.numpy(), mse_tsmixer.numpy(), mse_iTransformer.numpy(), mse_predrnn.numpy(), mse_our.numpy()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.13300127\n",
      "0.15952552552646165\n",
      "0.16357975\n",
      "0.16512617\n",
      "0.16510934\n",
      "0.16772293\n",
      "0.14073682\n"
     ]
    }
   ],
   "source": [
    "mae_our= (np.abs((prediction_our.mean(1)- labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_our))\n",
    "\n",
    "mae_xg = (np.abs((prediction_xg- labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_xg))\n",
    "\n",
    "mae_tsmixer = (np.abs((prediction_tsmixer - labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_tsmixer))\n",
    "\n",
    "mae_crossformer = (np.abs((prediction_crossformer - labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_crossformer))\n",
    "\n",
    "mae_mtgnn = (np.abs((prediction_mtgnn - labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_mtgnn))\n",
    "\n",
    "mae_iTransformer = (np.abs((prediction_iTransformer - labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_iTransformer))\n",
    "\n",
    "mae_predrnn = (np.abs((prediction_predrnn - labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_predrnn))\n",
    "\n",
    "\n",
    "mae_our[mae_our==0]=np.nan\n",
    "mae_xg[mae_xg==0]=np.nan\n",
    "mae_crossformer[mae_crossformer==0]=np.nan\n",
    "mae_mtgnn[mae_mtgnn==0]=np.nan\n",
    "mae_tsmixer[mae_tsmixer==0]=np.nan\n",
    "mae_iTransformer[mae_iTransformer==0]=np.nan\n",
    "mae_predrnn[mae_predrnn==0]=np.nan\n",
    "\n",
    "mae_list.extend([mae_xg.numpy(), mae_mtgnn.numpy(), mae_crossformer.numpy(), mae_tsmixer.numpy(), mae_iTransformer.numpy(), mae_predrnn.numpy(), mae_our.numpy()])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**prediction two year**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "base_dir = \"./log/prediction_46_92/{}/\".format(config.area)\n",
    "prediction_xg = np.load(base_dir+\"XGBoost/without_imputation/prediction_0.npy\", allow_pickle=True)\n",
    "prediction_our = load(base_dir+\"STIMP\")\n",
    "prediction_mtgnn = np.load(base_dir+\"MTGNN/without_imputation/prediction_0.npy\", allow_pickle=True)\n",
    "prediction_tsmixer = np.load(base_dir+\"TSMixer/without_imputation/prediction_0.npy\", allow_pickle=True)\n",
    "prediction_crossformer = np.load(base_dir+\"CrossFormer/without_imputation/prediction_0.npy\", allow_pickle=True)\n",
    "prediction_iTransformer = np.load(base_dir+\"iTransformer/without_imputation/prediction_0.npy\", allow_pickle=True)\n",
    "prediction_predrnn = np.load(base_dir+\"PredRNN/without_imputation/prediction_0.npy\", allow_pickle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "config.out_len = 92\n",
    "test_dloader = DataLoader(PRE8dDataset(config, mode='test'), config.batch_size, shuffle=False)\n",
    "\n",
    "labels_list = []\n",
    "label_masks_list = []\n",
    "\n",
    "for test_step, (datas, data_ob_masks, data_gt_masks, labels, label_masks) in enumerate(test_dloader):\n",
    "    labels_list.append(labels[:,:,0])\n",
    "    label_masks_list.append(label_masks[:,:,0])\n",
    "\n",
    "labels = torch.cat(labels_list, 0)\n",
    "label_masks = torch.cat(label_masks_list, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "label_masks = label_masks.squeeze()\n",
    "labels = labels.squeeze()\n",
    "\n",
    "prediction_our = torch.from_numpy(prediction_our).squeeze()\n",
    "prediction_xg = torch.from_numpy(prediction_xg).squeeze()\n",
    "prediction_tsmixer = torch.from_numpy(prediction_tsmixer).squeeze()\n",
    "prediction_mtgnn = torch.from_numpy(prediction_mtgnn).squeeze()\n",
    "prediction_crossformer = torch.from_numpy(prediction_crossformer).squeeze()\n",
    "prediction_iTransformer = torch.from_numpy(prediction_iTransformer).squeeze()\n",
    "prediction_predrnn = torch.from_numpy(prediction_predrnn).squeeze()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.031958424\n",
      "0.05186179539724158\n",
      "0.0530402\n",
      "0.053093884\n",
      "0.04661797\n",
      "0.053365033\n",
      "0.06833679\n"
     ]
    }
   ],
   "source": [
    "mse_our= (((prediction_our.mean(1)- labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_our))\n",
    "\n",
    "\n",
    "mse_xg = (((prediction_xg- labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_xg))\n",
    "\n",
    "mse_tsmixer = (((prediction_tsmixer - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_tsmixer))\n",
    "\n",
    "mse_crossformer = (((prediction_crossformer - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_crossformer))\n",
    "\n",
    "mse_mtgnn = (((prediction_mtgnn - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_mtgnn))\n",
    "\n",
    "mse_iTransformer = (((prediction_iTransformer - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_iTransformer))\n",
    "\n",
    "mse_predrnn = (((prediction_predrnn - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_predrnn))\n",
    "\n",
    "\n",
    "mse_our[mse_our==0]=np.nan\n",
    "mse_xg[mse_xg==0]=np.nan\n",
    "mse_crossformer[mse_crossformer==0]=np.nan\n",
    "mse_mtgnn[mse_mtgnn==0]=np.nan\n",
    "mse_tsmixer[mse_tsmixer==0]=np.nan\n",
    "mse_iTransformer[mse_iTransformer==0]=np.nan\n",
    "mse_predrnn[mse_predrnn==0]=np.nan\n",
    "\n",
    "\n",
    "\n",
    "category.extend([\"XGBoost\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"two\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"MTGNN\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"two\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"CrossFormer\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"two\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"TSMixer\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"two\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"iTransformer\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"two\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"PredRNN\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"two\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"STIMP\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"two\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "mse_list.extend([mse_xg.numpy(), mse_mtgnn.numpy(), mse_crossformer.numpy(), mse_tsmixer.numpy(), mse_iTransformer.numpy(), mse_predrnn.numpy(), mse_our.numpy()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.13389565\n",
      "0.16341268467506134\n",
      "0.16591498\n",
      "0.1689821\n",
      "0.15656155\n",
      "0.16874047\n",
      "0.19170742\n"
     ]
    }
   ],
   "source": [
    "mae_our= (np.abs((prediction_our.mean(1)- labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_our))\n",
    "\n",
    "mae_xg = (np.abs((prediction_xg- labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_xg))\n",
    "\n",
    "mae_tsmixer = (np.abs((prediction_tsmixer - labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_tsmixer))\n",
    "\n",
    "mae_crossformer = (np.abs((prediction_crossformer - labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_crossformer))\n",
    "\n",
    "mae_mtgnn = (np.abs((prediction_mtgnn - labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_mtgnn))\n",
    "\n",
    "mae_iTransformer = (np.abs((prediction_iTransformer - labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_iTransformer))\n",
    "\n",
    "mae_predrnn = (np.abs((prediction_predrnn - labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_predrnn))\n",
    "\n",
    "\n",
    "mae_our[mae_our==0]=np.nan\n",
    "mae_xg[mae_xg==0]=np.nan\n",
    "mae_crossformer[mae_crossformer==0]=np.nan\n",
    "mae_mtgnn[mae_mtgnn==0]=np.nan\n",
    "mae_tsmixer[mae_tsmixer==0]=np.nan\n",
    "mae_iTransformer[mae_iTransformer==0]=np.nan\n",
    "mae_predrnn[mae_predrnn==0]=np.nan\n",
    "\n",
    "mae_list.extend([mae_xg.numpy(), mae_mtgnn.numpy(), mae_crossformer.numpy(), mae_tsmixer.numpy(), mae_iTransformer.numpy(), mae_predrnn.numpy(), mae_our.numpy()])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**prediction three years**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "base_dir = \"./log/prediction_46_138/{}/\".format(config.area)\n",
    "prediction_xg = np.load(base_dir+\"XGBoost/without_imputation/prediction_0.npy\", allow_pickle=True)\n",
    "prediction_our = load(base_dir+\"STIMP\")\n",
    "prediction_mtgnn = np.load(base_dir+\"MTGNN/without_imputation/prediction_0.npy\", allow_pickle=True)\n",
    "prediction_tsmixer = np.load(base_dir+\"TSMixer/without_imputation/prediction_0.npy\", allow_pickle=True)\n",
    "prediction_crossformer = np.load(base_dir+\"CrossFormer/without_imputation/prediction_0.npy\", allow_pickle=True)\n",
    "prediction_iTransformer = np.load(base_dir+\"iTransformer/without_imputation/prediction_0.npy\", allow_pickle=True)\n",
    "prediction_predrnn = np.load(base_dir+\"PredRNN/without_imputation/prediction_0.npy\", allow_pickle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "config.out_len = 138\n",
    "test_dloader = DataLoader(PRE8dDataset(config, mode='test'), config.batch_size, shuffle=False)\n",
    "\n",
    "labels_list = []\n",
    "label_masks_list = []\n",
    "\n",
    "for test_step, (datas, data_ob_masks, data_gt_masks, labels, label_masks) in enumerate(test_dloader):\n",
    "    labels_list.append(labels[:,:,0])\n",
    "    label_masks_list.append(label_masks[:,:,0])\n",
    "\n",
    "labels = torch.cat(labels_list, 0)\n",
    "label_masks = torch.cat(label_masks_list, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "label_masks = label_masks.squeeze()\n",
    "labels = labels.squeeze()\n",
    "\n",
    "prediction_our = torch.from_numpy(prediction_our).squeeze()\n",
    "prediction_xg = torch.from_numpy(prediction_xg).squeeze()\n",
    "prediction_tsmixer = torch.from_numpy(prediction_tsmixer).squeeze()\n",
    "prediction_mtgnn = torch.from_numpy(prediction_mtgnn).squeeze()\n",
    "prediction_crossformer = torch.from_numpy(prediction_crossformer).squeeze()\n",
    "prediction_iTransformer = torch.from_numpy(prediction_iTransformer).squeeze()\n",
    "prediction_predrnn = torch.from_numpy(prediction_predrnn).squeeze()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.03351087\n",
      "0.05385529012549861\n",
      "0.05481568\n",
      "0.055788737\n",
      "0.053814176\n",
      "0.054803226\n",
      "0.074919365\n"
     ]
    }
   ],
   "source": [
    "mse_our= (((prediction_our.mean(1)- labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_our))\n",
    "\n",
    "mse_xg = (((prediction_xg- labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_xg))\n",
    "\n",
    "mse_tsmixer = (((prediction_tsmixer - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_tsmixer))\n",
    "\n",
    "mse_crossformer = (((prediction_crossformer - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_crossformer))\n",
    "\n",
    "mse_mtgnn = (((prediction_mtgnn - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_mtgnn))\n",
    "\n",
    "mse_iTransformer = (((prediction_iTransformer - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_iTransformer))\n",
    "\n",
    "mse_predrnn = (((prediction_predrnn - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mse_predrnn))\n",
    "\n",
    "\n",
    "mse_our[mse_our==0]=np.nan\n",
    "mse_xg[mse_xg==0]=np.nan\n",
    "mse_crossformer[mse_crossformer==0]=np.nan\n",
    "mse_mtgnn[mse_mtgnn==0]=np.nan\n",
    "mse_tsmixer[mse_tsmixer==0]=np.nan\n",
    "mse_iTransformer[mse_iTransformer==0]=np.nan\n",
    "mse_predrnn[mse_predrnn==0]=np.nan\n",
    "\n",
    "\n",
    "category.extend([\"XGBoost\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"three\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"MTGNN\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"three\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"CrossFormer\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"three\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"TSMixer\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"three\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"iTransformer\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"three\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"PredRNN\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"three\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "category.extend([\"STIMP\" for i in range(mse_our.shape[-1])])\n",
    "pred_len.extend([\"three\" for i in range(mse_our.shape[-1])])\n",
    "\n",
    "mse_list.extend([mse_xg.numpy(), mse_mtgnn.numpy(), mse_crossformer.numpy(), mse_tsmixer.numpy(), mse_iTransformer.numpy(), mse_predrnn.numpy(), mse_our.numpy()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.13760743\n",
      "0.16764102715290105\n",
      "0.16985057\n",
      "0.17287153\n",
      "0.16906618\n",
      "0.17056586\n",
      "0.20103307\n"
     ]
    }
   ],
   "source": [
    "mae_our= (np.abs((prediction_our.mean(1)- labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_our))\n",
    "\n",
    "mae_xg = (np.abs((prediction_xg- labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_xg))\n",
    "\n",
    "mae_tsmixer = (np.abs((prediction_tsmixer - labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_tsmixer))\n",
    "\n",
    "mae_crossformer = (np.abs((prediction_crossformer - labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_crossformer))\n",
    "\n",
    "mae_mtgnn = (np.abs((prediction_mtgnn - labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_mtgnn))\n",
    "\n",
    "mae_iTransformer = (np.abs((prediction_iTransformer - labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_iTransformer))\n",
    "\n",
    "mae_predrnn = (np.abs((prediction_predrnn - labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "print(np.nanmean(mae_predrnn))\n",
    "\n",
    "\n",
    "mae_our[mae_our==0]=np.nan\n",
    "mae_xg[mae_xg==0]=np.nan\n",
    "mae_crossformer[mae_crossformer==0]=np.nan\n",
    "mae_mtgnn[mae_mtgnn==0]=np.nan\n",
    "mae_tsmixer[mae_tsmixer==0]=np.nan\n",
    "mae_iTransformer[mae_iTransformer==0]=np.nan\n",
    "mae_predrnn[mae_predrnn==0]=np.nan\n",
    "\n",
    "mae_list.extend([mae_xg.numpy(), mae_mtgnn.numpy(), mae_crossformer.numpy(), mae_tsmixer.numpy(), mae_iTransformer.numpy(), mae_predrnn.numpy(), mae_our.numpy()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(62.853375, 0.5, 'MSE')"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 651.5x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "data = {'mse': np.concatenate(mse_list, axis=0),\n",
    "        'methods':category,\n",
    "        'prediction years':pred_len}\n",
    "data = pd.DataFrame.from_dict(data)\n",
    "sns.set(style=\"whitegrid\")\n",
    "plt.xticks(rotation=30)\n",
    "color_palette = [\"#FF0000\", \"#8C564B\",  \"#2CA02C\", \"#FFCC00\", \"#1F77B4\", \"#9467BD\",\"#FF7F0E\"][::-1]\n",
    "\n",
    "g = sns.catplot(x=\"prediction years\", y=\"mse\", hue=\"methods\", kind=\"point\", data=data, palette=sns.color_palette(color_palette),ci=None)\n",
    "plt.yticks(fontsize=14)\n",
    "plt.xticks(fontsize=14)\n",
    "plt.xlabel(\"prediction years\",fontsize=16)\n",
    "plt.ylabel(\"MSE\",fontsize=16)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(62.853375, 0.5, 'MAE')"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 651.5x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "data = {'mae': np.concatenate(mae_list, axis=0),\n",
    "        'methods':category,\n",
    "        'prediction years':pred_len}\n",
    "data = pd.DataFrame.from_dict(data)\n",
    "sns.set(style=\"whitegrid\")\n",
    "plt.xticks(rotation=30)\n",
    "\n",
    "g = sns.catplot(x=\"prediction years\", y=\"mae\", hue=\"methods\", kind=\"point\", data=data, palette=sns.color_palette(color_palette),ci=None)\n",
    "plt.yticks(fontsize=14)\n",
    "plt.xticks(fontsize=14)\n",
    "plt.xlabel(\"prediction years\",fontsize=16)\n",
    "plt.ylabel(\"MAE\",fontsize=16)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "torch211",
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}