{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Different Prediction Horizons in Yangtze River Estuary"
   ]
  },
  {
   "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='Yangtze', 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.07367923\n",
      "0.1207363835498583\n",
      "0.094932795\n",
      "0.102482446\n",
      "0.104724154\n",
      "0.11360377\n",
      "0.08285413\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.19370107\n",
      "0.2758264802292547\n",
      "0.23346716\n",
      "0.24123296\n",
      "0.2506511\n",
      "0.25590324\n",
      "0.2096451\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.07682079\n",
      "0.12341209618145238\n",
      "0.09286432\n",
      "0.09770192\n",
      "0.09482597\n",
      "0.11026872\n",
      "0.13772267\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.19881311\n",
      "0.2788288029870517\n",
      "0.23034102\n",
      "0.23559779\n",
      "0.23465866\n",
      "0.25518334\n",
      "0.2907447\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.0798209\n",
      "0.1259873151242834\n",
      "0.099159166\n",
      "0.10291438\n",
      "0.09591704\n",
      "0.11124313\n",
      "0.14575765\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.20248224\n",
      "0.2823383419585967\n",
      "0.24083532\n",
      "0.24157773\n",
      "0.23470001\n",
      "0.25702506\n",
      "0.30405876\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": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(62.853375, 0.5, 'MSE')"
      ]
     },
     "execution_count": 19,
     "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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(62.853375, 0.5, 'MAE')"
      ]
     },
     "execution_count": 20,
     "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",
    "color_palette = [\"#FF0000\", \"#8C564B\",  \"#2CA02C\", \"#FFCC00\", \"#1F77B4\", \"#9467BD\",\"#FF7F0E\"][::-1]\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
}