{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Recurrent Prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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": null,
   "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": null,
   "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": null,
   "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='PRE', 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)\n",
    "label_masks = label_masks.squeeze()\n",
    "labels = labels.squeeze()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "base_dir = \"./log/prediction_46_46/{}/\".format(config.area)\n",
    "prediction_our = load(base_dir+\"STIMP\")\n",
    "prediction_our = torch.from_numpy(prediction_our).squeeze()\n",
    "mse_our= (((prediction_our.mean(1) - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mse_our[mse_our==0]=np.nan\n",
    "# category.extend([\"STIMP (Pearl River Estuary)\" for i in range(mse_our.shape[-1])])\n",
    "# pred_len.extend([\"one\" for i in range(mse_our.shape[-1])])\n",
    "# category.extend([\"STIMP recurrent (Pearl River Estuary)\" for i in range(mse_our.shape[-1])])\n",
    "# pred_len.extend([\"one\" for i in range(mse_our.shape[-1])])\n",
    "# mse_list.extend([mse_our.numpy(), mse_our.numpy()])\n",
    "\n",
    "category.extend([\"STIMP (Pearl River Estuary)\"])\n",
    "pred_len.extend([\"one\"])\n",
    "category.extend([\"STIMP recurrent (Pearl River Estuary)\"])\n",
    "pred_len.extend([\"one\"])\n",
    "mse_list.extend([np.nanmean(mse_our), np.nanmean(mse_our)])\n",
    "\n",
    "mae_our= (np.abs((prediction_our.mean(1)- labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mae_our[mae_our==0]=np.nan\n",
    "mae_list.extend([np.nanmean(mae_our), np.nanmean(mae_our)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "config.area=\"MEXICO\"\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)\n",
    "label_masks = label_masks.squeeze()\n",
    "labels = labels.squeeze()\n",
    "base_dir = \"./log/prediction_46_46/{}/\".format(config.area)\n",
    "prediction_our = load(base_dir+\"STIMP\")\n",
    "prediction_our = torch.from_numpy(prediction_our).squeeze()\n",
    "mse_our= (((prediction_our.mean(1) - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mse_our[mse_our==0]=np.nan\n",
    "category.extend([\"STIMP (The Gulf of Mexico)\"])\n",
    "pred_len.extend([\"one\"])\n",
    "category.extend([\"STIMP recurrent (The Gulf of Mexico)\"])\n",
    "pred_len.extend([\"one\"])\n",
    "mse_list.extend([np.nanmean(mse_our), np.nanmean(mse_our)])\n",
    "mae_our= (np.abs((prediction_our.mean(1)- labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mae_our[mae_our==0]=np.nan\n",
    "mae_list.extend([np.nanmean(mae_our), np.nanmean(mae_our)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "config.area=\"Chesapeake\"\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)\n",
    "label_masks = label_masks.squeeze()\n",
    "labels = labels.squeeze()\n",
    "base_dir = \"./log/prediction_46_46/{}/\".format(config.area)\n",
    "prediction_our = load(base_dir+\"STIMP\")\n",
    "prediction_our = torch.from_numpy(prediction_our).squeeze()\n",
    "mse_our= (((prediction_our.mean(1) - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mse_our[mse_our==0]=np.nan\n",
    "category.extend([\"STIMP (Chesapeake Bay)\"])\n",
    "pred_len.extend([\"one\"])\n",
    "category.extend([\"STIMP recurrent (Chesapeake Bay)\"])\n",
    "pred_len.extend([\"one\"])\n",
    "mse_list.extend([np.nanmean(mse_our), np.nanmean(mse_our)])\n",
    "mae_our= (np.abs((prediction_our.mean(1)- labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mae_our[mae_our==0]=np.nan\n",
    "mae_list.extend([np.nanmean(mae_our), np.nanmean(mae_our)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "config.area=\"Yangtze\"\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)\n",
    "label_masks = label_masks.squeeze()\n",
    "labels = labels.squeeze()\n",
    "base_dir = \"./log/prediction_46_46/{}/\".format(config.area)\n",
    "prediction_our = load(base_dir+\"STIMP\")\n",
    "prediction_our = torch.from_numpy(prediction_our).squeeze()\n",
    "mse_our= (((prediction_our.mean(1) - labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mse_our[mse_our==0]=np.nan\n",
    "category.extend([\"STIMP (Yangtze River Estuary)\"])\n",
    "pred_len.extend([\"one\"])\n",
    "category.extend([\"STIMP recurrent (Yangtze River Estuary)\"])\n",
    "pred_len.extend([\"one\"])\n",
    "mse_list.extend([np.nanmean(mse_our), np.nanmean(mse_our)])\n",
    "mae_our= (np.abs((prediction_our.mean(1)- labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mae_our[mae_our==0]=np.nan\n",
    "mae_list.extend([np.nanmean(mae_our), np.nanmean(mae_our)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "config.out_len = 92\n",
    "config.area = \"PRE\"\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)\n",
    "label_masks = label_masks.squeeze()\n",
    "labels = labels.squeeze()\n",
    "\n",
    "base_dir = \"./log/prediction_46_{}/{}/\".format(config.out_len, config.area)\n",
    "prediction_our = load(base_dir+\"STIMP\")\n",
    "prediction_our = torch.from_numpy(prediction_our).squeeze()\n",
    "prediction_our_recurrently = np.stack([np.load(\"./log/prediction_recu_46_{}/PRE/STIMP/prediction_{}.npy\".format(config.out_len, i)) for i in range(10)], axis=1)\n",
    "prediction_our_recurrently = torch.from_numpy(prediction_our_recurrently).squeeze()\n",
    "mse_our= (((prediction_our.mean(1)- labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mse_our_recurrently = (((prediction_our_recurrently.mean(1)- labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mse_our[mse_our==0]=np.nan\n",
    "mse_our_recurrently[mse_our_recurrently==0]=np.nan\n",
    "\n",
    "category.extend([\"STIMP (Pearl River Estuary)\"])\n",
    "pred_len.extend([\"two\"])\n",
    "category.extend([\"STIMP recurrent (Pearl River Estuary)\"])\n",
    "pred_len.extend([\"two\"])\n",
    "mse_list.extend([np.nanmean(mse_our), np.nanmean(mse_our_recurrently)])\n",
    "\n",
    "mae_our= (np.abs((prediction_our.mean(1)- labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mae_our_recurrently = (np.abs((prediction_our_recurrently.mean(1)- labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mae_our[mae_our==0]=np.nan\n",
    "mae_our_recurrently[mae_our_recurrently==0]=np.nan\n",
    "mae_list.extend([np.nanmean(mae_our), np.nanmean(mae_our_recurrently)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "config.area = \"MEXICO\"\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)\n",
    "label_masks = label_masks.squeeze()\n",
    "labels = labels.squeeze()\n",
    "\n",
    "base_dir = \"./log/prediction_46_{}/{}/\".format(config.out_len, config.area)\n",
    "prediction_our = load(base_dir+\"STIMP\")\n",
    "prediction_our = torch.from_numpy(prediction_our).squeeze()\n",
    "prediction_our_recurrently = np.stack([np.load(\"./log/prediction_recu_46_{}/{}/STIMP/prediction_{}.npy\".format(config.out_len, config.area, i)) for i in range(10)], axis=1)\n",
    "prediction_our_recurrently = torch.from_numpy(prediction_our_recurrently).squeeze()\n",
    "mse_our= (((prediction_our.mean(1)- labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mse_our_recurrently = (((prediction_our_recurrently.mean(1)- labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mse_our[mse_our==0]=np.nan\n",
    "mse_our_recurrently[mse_our_recurrently==0]=np.nan\n",
    "\n",
    "category.extend([\"STIMP (The Gulf of Mexico)\"])\n",
    "pred_len.extend([\"two\"])\n",
    "category.extend([\"STIMP recurrent (The Gulf of Mexico)\"])\n",
    "pred_len.extend([\"two\"])\n",
    "mse_list.extend([np.nanmean(mse_our), np.nanmean(mse_our_recurrently)])\n",
    "\n",
    "mae_our= (np.abs((prediction_our.mean(1)- labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mae_our_recurrently = (np.abs((prediction_our_recurrently.mean(1)- labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mae_our[mae_our==0]=np.nan\n",
    "mae_our_recurrently[mae_our_recurrently==0]=np.nan\n",
    "mae_list.extend([np.nanmean(mae_our), np.nanmean(mae_our_recurrently)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "config.area = \"Chesapeake\"\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)\n",
    "label_masks = label_masks.squeeze()\n",
    "labels = labels.squeeze()\n",
    "\n",
    "base_dir = \"./log/prediction_46_{}/{}/\".format(config.out_len, config.area)\n",
    "prediction_our = load(base_dir+\"STIMP\")\n",
    "prediction_our = torch.from_numpy(prediction_our).squeeze()\n",
    "prediction_our_recurrently = np.stack([np.load(\"./log/prediction_recu_46_{}/{}/STIMP/prediction_{}.npy\".format(config.out_len, config.area, i)) for i in range(10)], axis=1)\n",
    "prediction_our_recurrently = torch.from_numpy(prediction_our_recurrently).squeeze()\n",
    "mse_our= (((prediction_our.mean(1)- labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mse_our_recurrently = (((prediction_our_recurrently.mean(1)- labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mse_our[mse_our==0]=np.nan\n",
    "mse_our_recurrently[mse_our_recurrently==0]=np.nan\n",
    "\n",
    "category.extend([\"STIMP (Chesapeake Bay)\"])\n",
    "pred_len.extend([\"two\"])\n",
    "category.extend([\"STIMP recurrent (Chesapeake Bay)\"])\n",
    "pred_len.extend([\"two\"])\n",
    "mse_list.extend([np.nanmean(mse_our), np.nanmean(mse_our_recurrently)])\n",
    "\n",
    "mae_our= (np.abs((prediction_our.mean(1)- labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mae_our_recurrently = (np.abs((prediction_our_recurrently.mean(1)- labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mae_our[mae_our==0]=np.nan\n",
    "mae_our_recurrently[mae_our_recurrently==0]=np.nan\n",
    "mae_list.extend([np.nanmean(mae_our), np.nanmean(mae_our_recurrently)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "config.area = \"Yangtze\"\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)\n",
    "label_masks = label_masks.squeeze()\n",
    "labels = labels.squeeze()\n",
    "\n",
    "base_dir = \"./log/prediction_46_{}/{}/\".format(config.out_len, config.area)\n",
    "prediction_our = load(base_dir+\"STIMP\")\n",
    "prediction_our = torch.from_numpy(prediction_our).squeeze()\n",
    "prediction_our_recurrently = np.stack([np.load(\"./log/prediction_recu_46_{}/{}/STIMP/prediction_{}.npy\".format(config.out_len, config.area, i)) for i in range(10)], axis=1)\n",
    "prediction_our_recurrently = torch.from_numpy(prediction_our_recurrently).squeeze()\n",
    "mse_our= (((prediction_our.mean(1)- labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mse_our_recurrently = (((prediction_our_recurrently.mean(1)- labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mse_our[mse_our==0]=np.nan\n",
    "mse_our_recurrently[mse_our_recurrently==0]=np.nan\n",
    "\n",
    "category.extend([\"STIMP (Yangtze River Estuary)\"])\n",
    "pred_len.extend([\"two\"])\n",
    "category.extend([\"STIMP recurrent (Yangtze River Estuary)\"])\n",
    "pred_len.extend([\"two\"])\n",
    "mse_list.extend([np.nanmean(mse_our), np.nanmean(mse_our_recurrently)])\n",
    "\n",
    "mae_our= (np.abs((prediction_our.mean(1)- labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mae_our_recurrently = (np.abs((prediction_our_recurrently.mean(1)- labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mae_our[mae_our==0]=np.nan\n",
    "mae_our_recurrently[mae_our_recurrently==0]=np.nan\n",
    "mae_list.extend([np.nanmean(mae_our), np.nanmean(mae_our_recurrently)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.07341199, 0.07341199, 0.0687093, 0.0687093, 0.03125612, 0.03125612, 0.07367923, 0.07367923, 0.074738964, 0.078052945, 0.06949424, 0.06978826, 0.031958424, 0.03171333, 0.07682079, 0.081702776]\n"
     ]
    }
   ],
   "source": [
    "print(mse_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**prediction three years**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "config.out_len = 138\n",
    "config.area = \"PRE\"\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)\n",
    "label_masks = label_masks.squeeze()\n",
    "labels = labels.squeeze()\n",
    "\n",
    "base_dir = \"./log/prediction_46_{}/{}/\".format(config.out_len, config.area)\n",
    "prediction_our = load(base_dir+\"STIMP\")\n",
    "prediction_our = torch.from_numpy(prediction_our).squeeze()\n",
    "prediction_our_recurrently = np.stack([np.load(\"./log/prediction_recu_46_{}/PRE/STIMP/prediction_{}.npy\".format(config.out_len, i)) for i in range(10)], axis=1)\n",
    "prediction_our_recurrently = torch.from_numpy(prediction_our_recurrently).squeeze()\n",
    "mse_our= (((prediction_our.mean(1)- labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mse_our_recurrently = (((prediction_our_recurrently.mean(1)- labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mse_our[mse_our==0]=np.nan\n",
    "mse_our_recurrently[mse_our_recurrently==0]=np.nan\n",
    "\n",
    "category.extend([\"STIMP (Pearl River Estuary)\"])\n",
    "pred_len.extend([\"three\"])\n",
    "category.extend([\"STIMP recurrent (Pearl River Estuary)\"])\n",
    "pred_len.extend([\"three\"])\n",
    "mse_list.extend([np.nanmean(mse_our), np.nanmean(mse_our_recurrently)])\n",
    "\n",
    "mae_our= (np.abs((prediction_our.mean(1)- labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mae_our_recurrently = (np.abs((prediction_our_recurrently.mean(1)- labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mae_our[mae_our==0]=np.nan\n",
    "mae_our_recurrently[mae_our_recurrently==0]=np.nan\n",
    "mae_list.extend([np.nanmean(mae_our), np.nanmean(mae_our_recurrently)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "config.area = \"MEXICO\"\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)\n",
    "label_masks = label_masks.squeeze()\n",
    "labels = labels.squeeze()\n",
    "\n",
    "base_dir = \"./log/prediction_46_{}/{}/\".format(config.out_len, config.area)\n",
    "prediction_our = load(base_dir+\"STIMP\")\n",
    "prediction_our = torch.from_numpy(prediction_our).squeeze()\n",
    "prediction_our_recurrently = np.stack([np.load(\"./log/prediction_recu_46_{}/{}/STIMP/prediction_{}.npy\".format(config.out_len, config.area, i)) for i in range(10)], axis=1)\n",
    "prediction_our_recurrently = torch.from_numpy(prediction_our_recurrently).squeeze()\n",
    "mse_our= (((prediction_our.mean(1)- labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mse_our_recurrently = (((prediction_our_recurrently.mean(1)- labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mse_our[mse_our==0]=np.nan\n",
    "mse_our_recurrently[mse_our_recurrently==0]=np.nan\n",
    "\n",
    "category.extend([\"STIMP (The Gulf of Mexico)\" ])\n",
    "pred_len.extend([\"three\"])\n",
    "category.extend([\"STIMP recurrent (The Gulf of Mexico)\"])\n",
    "pred_len.extend([\"three\"])\n",
    "mse_list.extend([np.nanmean(mse_our), np.nanmean(mse_our_recurrently)])\n",
    "\n",
    "mae_our= (np.abs((prediction_our.mean(1)- labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mae_our_recurrently = (np.abs((prediction_our_recurrently.mean(1)- labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mae_our[mae_our==0]=np.nan\n",
    "mae_our_recurrently[mae_our_recurrently==0]=np.nan\n",
    "mae_list.extend([np.nanmean(mae_our), np.nanmean(mae_our_recurrently)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "config.area = \"Chesapeake\"\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)\n",
    "label_masks = label_masks.squeeze()\n",
    "labels = labels.squeeze()\n",
    "\n",
    "base_dir = \"./log/prediction_46_{}/{}/\".format(config.out_len, config.area)\n",
    "prediction_our = load(base_dir+\"STIMP\")\n",
    "prediction_our = torch.from_numpy(prediction_our).squeeze()\n",
    "prediction_our_recurrently = np.stack([np.load(\"./log/prediction_recu_46_{}/{}/STIMP/prediction_{}.npy\".format(config.out_len, config.area, i)) for i in range(10)], axis=1)\n",
    "prediction_our_recurrently = torch.from_numpy(prediction_our_recurrently).squeeze()\n",
    "mse_our= (((prediction_our.mean(1)- labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mse_our_recurrently = (((prediction_our_recurrently.mean(1)- labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mse_our[mse_our==0]=np.nan\n",
    "mse_our_recurrently[mse_our_recurrently==0]=np.nan\n",
    "\n",
    "category.extend([\"STIMP (Chesapeake Bay)\"])\n",
    "pred_len.extend([\"three\"])\n",
    "category.extend([\"STIMP recurrent (Chesapeake Bay)\"])\n",
    "pred_len.extend([\"three\"])\n",
    "mse_list.extend([np.nanmean(mse_our), np.nanmean(mse_our_recurrently)])\n",
    "\n",
    "mae_our= (np.abs((prediction_our.mean(1)- labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mae_our_recurrently = (np.abs((prediction_our_recurrently.mean(1)- labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mae_our[mae_our==0]=np.nan\n",
    "mae_our_recurrently[mae_our_recurrently==0]=np.nan\n",
    "mae_list.extend([np.nanmean(mae_our), np.nanmean(mae_our_recurrently)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "config.area = \"Yangtze\"\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)\n",
    "label_masks = label_masks.squeeze()\n",
    "labels = labels.squeeze()\n",
    "\n",
    "base_dir = \"./log/prediction_46_{}/{}/\".format(config.out_len, config.area)\n",
    "prediction_our = load(base_dir+\"STIMP\")\n",
    "prediction_our = torch.from_numpy(prediction_our).squeeze()\n",
    "prediction_our_recurrently = np.stack([np.load(\"./log/prediction_recu_46_{}/{}/STIMP/prediction_{}.npy\".format(config.out_len, config.area, i)) for i in range(10)], axis=1)\n",
    "prediction_our_recurrently = torch.from_numpy(prediction_our_recurrently).squeeze()\n",
    "mse_our= (((prediction_our.mean(1)- labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mse_our_recurrently = (((prediction_our_recurrently.mean(1)- labels)*label_masks)**2).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mse_our[mse_our==0]=np.nan\n",
    "mse_our_recurrently[mse_our_recurrently==0]=np.nan\n",
    "\n",
    "category.extend([\"STIMP (Yangtze River Estuary)\"])\n",
    "pred_len.extend([\"three\"])\n",
    "category.extend([\"STIMP recurrent (Yangtze River Estuary)\"])\n",
    "pred_len.extend([\"three\"])\n",
    "mse_list.extend([np.nanmean(mse_our), np.nanmean(mse_our_recurrently)])\n",
    "\n",
    "mae_our= (np.abs((prediction_our.mean(1)- labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mae_our_recurrently = (np.abs((prediction_our_recurrently.mean(1)- labels)*label_masks)).sum([0,1])/(label_masks.sum([0,1])+1e-5)\n",
    "mae_our[mae_our==0]=np.nan\n",
    "mae_our_recurrently[mae_our_recurrently==0]=np.nan\n",
    "mae_list.extend([np.nanmean(mae_our), np.nanmean(mae_our_recurrently)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.07341199, 0.07341199, 0.0687093, 0.0687093, 0.03125612, 0.03125612, 0.07367923, 0.07367923, 0.074738964, 0.078052945, 0.06949424, 0.06978826, 0.031958424, 0.03171333, 0.07682079, 0.081702776, 0.07729962, 0.081726074, 0.073826, 0.07507951, 0.03351087, 0.03377057, 0.0798209, 0.088545464]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAGxCAYAAACeKZf2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8WgzjOAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAn50lEQVR4nO3de3SU9Z3H8c+EJOTGDI2EOyUkLcjWAwgEiMEIlqDBdkGCNbR4Qqgl62bVBreVui6FgghBqSVQUQQTswpKdVkOLmjcViMJWK9QXQ8NCREKNYRoM0PIjcyzf7iJphjkyfXxx/t1To/N4/xmfpOvGd7MPDNxWZZlCQAAwBABPb0BAACAzkTcAAAAoxA3AADAKMQNAAAwCnEDAACMQtwAAACjEDcAAMAoxA0AADAKcQMAAIxiO24++ugjLVu2TLNnz9Y//MM/6Hvf+94lrbMsS48//rimTZumMWPG6NZbb9V7771n9+YBAAAuynbclJSU6LXXXtPw4cMVGxt7yeu2bNmiDRs2aOHChXrssccUFRWlRYsW6cSJE3a3AAAA0CaX3d8t5ff7FRDwWRMtXbpU77//vvbs2XPRNfX19brmmmv0ox/9SEuWLJEkNTQ06MYbb1RiYqKWL1/evt0DAAD8HdvP3DSHjR3vvPOOzp49q+Tk5JZjwcHBSkpKUmFhoe3rAwAAaEtgd9xIWVmZJCkmJqbV8djYWOXl5amurk4hISG2rvPdd9+VZVkKCgrqtH0CAICu1djYKJfLpauvvrrLbqNb4sbr9So4OFi9e/duddztdsuyLFVXV9uOG8uyZFmWGhoaOnOrAADga65b4qYrBAUFqaGhQdHR0QoNDe3p7Vz2amtrVV5ezjwcgFk4B7NwDmbhHCUlJe06xcWObokbt9uthoYG1dfXt3r2xuv1yuVyyePxtPu6Q0NDFRYW1hnbRCdgHs7BLJyDWTgHs+h5Lpery2+jWz7Er/lcm2PHjrU6XlZWpsGDB9t+SQoAAKAt3RI348ePV0REhPbu3dtyrLGxUS+//LISExO7YwsAAOAyYftlqdraWr322muSpJMnT+rs2bPat2+fJGnSpEmKjIxUWlqaTp06pYKCAklS7969lZGRoZycHEVGRmrkyJHavn27/va3v+nHP/5xJ94dAABwubMdN1VVVbr77rtbHWv++qmnntLkyZPl9/vV1NTU6jI/+clPZFmWtm3bpk8++USjR4/W1q1bNWzYsA5sHwAAoDXbcTN06FAdOXLkopfJz8+/4JjL5VJGRoYyMjLs3iQAAMAl47eCAwAAoxA3AADAKMQNAAAwCnEDAACMQtwAAACjEDcAAMAoxA0AADAKcQMAAIxC3AAAAKMQNwAAwCjEDQAAMApxAwAAjELcAAAAoxA3AADAKMQNAAAwCnEDAACMQtwAAACjEDcAAMAoxA0AADAKcQMAAIxC3AAAAKMQNwAAwCjEDQAAMApxAwAAjELcAAAAoxA3AADAKMQNAAAwCnEDAACMQtwAAACjEDcAAMAoxA0AADAKcQMAAIxC3AAAAKMQNwAAwCjEDQAAMApxAwAAjELcAAAAoxA3AADAKMQNAAAwCnEDAACMQtwAAACjEDcAAMAoxA0AADAKcQMAAIxC3AAAAKMQNwAAwCjEDQAAMApxAwAAjELcAAAAoxA3AADAKMQNAAAwCnEDAACMQtwAAACjEDcAAMAoxA0AADAKcQMAAIxC3AAAAKMQNwAAwCjEDQAAMApxAwAAjELcAAAAo9iOm9LSUqWnp2vcuHFKSEhQdna2GhoavnLdp59+qmXLlmnatGkaN26cvve972n79u3t2jQAAEBbAu1cuLq6WmlpaYqOjlZOTo4qKiq0Zs0a1dXVadmyZRdde/fdd6usrExLlizRoEGDVFhYqOXLl6tXr176wQ9+0KE7AQAA0MxW3OzYsUM1NTXauHGj+vbtK0lqamrSihUrlJGRoQEDBnzpusrKSr3xxht68MEHNXfuXElSfHy8/vSnP+nFF18kbgAAQKex9bJUYWGh4uPjW8JGkpKTk+X3+1VUVNTmuvPnz0uS+vTp0+p4RESELMuyswUAAICLsvXMTVlZmVJSUlodc7vdioqKUllZWZvrBg0apKlTp2rz5s0aMWKEBg4cqMLCQhUVFemhhx5q387/X21tbYfWo3M0z4F59Dxm4RzMwjmYhXNYliWXy9Wlt2Erbrxer9xu9wXHPR6PqqurL7o2JydHWVlZuummmyRJvXr10v33368bbrjBzhYuUF5e3qH16FzMwzmYhXMwC+dgFs4QHBzcpddvK27ay7Is/eIXv1B5ebkefvhhRUVFqbi4WKtXr5bH42kJnvaIjo5WaGhoJ+4W7VFbW6vy8nLm4QDMwjmYhXMwC+coKSnp8tuwFTdut1s+n++C49XV1fJ4PG2ue/XVV7Vv3z7t3r1bo0aNkiRNnjxZVVVVWrNmTYfiJjQ0VGFhYe1ej87FPJyDWTgHs3AOZtHzuvolKcnmCcUxMTEXnFvj8/lUWVmpmJiYNtcdPXpUvXr10siRI1sdHz16tE6fPs1roAAAoNPYipvExEQVFxfL6/W2HNu3b58CAgKUkJDQ5rohQ4aoqalJR44caXX8gw8+0BVXXMFThAAAoNPYipvU1FSFh4crMzNT+/fv1/PPP6/s7Gylpqa2+oybtLQ0JSUltXydmJiowYMH66677tJ//dd/6cCBA1q3bp3+8z//UwsWLOi8ewMAAC57ts658Xg8ysvL08qVK5WZmanw8HDNmzdPWVlZrS7n9/vV1NTU8nVERIRyc3P161//Wg899JB8Pp+GDh2qpUuXEjcAAKBT2X63VGxsrHJzcy96mfz8/AuODR8+XI888ojdmwMAALCF3woOAACMQtwAAACjEDcAAMAoxA0AADAKcQMAAIxC3AAAAKMQNwAAwCjEDQAAMApxAwAAjELcAAAAoxA3AADAKMQNAAAwCnEDAACMQtwAAACjEDcAAMAoxA0AADAKcQMAAIxC3AAAAKMQNwAAwCjEDQAAMApxAwAAjELcAAAAoxA3AADAKMQNAAAwCnEDAACMQtwAAACjEDcAAMAoxA0AADAKcQMAAIxC3AAAAKMQNwAAwCjEDQAAMApxAwAAjELcAAAAoxA3AADAKMQNAAAwCnEDAACMQtwAAACjEDcAAMAoxA0AADAKcQMAAIxC3AAAAKMQNwAAwCjEDQAAMApxAwAAjELcAAAAoxA3AADAKMQNAAAwCnEDAACMQtwAAACjEDcAAMAoxA0AADAKcQMAAIxC3AAAAKMQNwAAwCjEDQAAMApxAwAAjELcAAAAoxA3AADAKMQNAAAwCnEDAACMYjtuSktLlZ6ernHjxikhIUHZ2dlqaGi4pLUVFRW69957NWXKFI0ZM0bJycnavXu37U0DAAC0JdDOhaurq5WWlqbo6Gjl5OSooqJCa9asUV1dnZYtW3bRtadPn9att96qESNGaOXKlYqIiFBJScklhxEAAMClsBU3O3bsUE1NjTZu3Ki+fftKkpqamrRixQplZGRowIABba5dt26dBg4cqCeeeEK9evWSJMXHx7d/5wAAAF/C1stShYWFio+PbwkbSUpOTpbf71dRUVGb686ePau9e/fqhz/8YUvYAAAAdAVbz9yUlZUpJSWl1TG3262oqCiVlZW1ue6DDz5QY2OjAgMDtWDBAr377rvq27ev5syZo5/+9KcKCgpq3+4l1dbWtnstOk/zHJhHz2MWzsEsnINZOIdlWXK5XF16G7bixuv1yu12X3Dc4/Gourq6zXVnzpyRJN1///36wQ9+oH/5l3/R4cOHtWHDBgUEBOiee+6xue3PlZeXt3stOh/zcA5m4RzMwjmYhTMEBwd36fXbipv28vv9kqRrrrlGS5culSRNmTJFNTU12rZtmzIzMxUSEtKu646OjlZoaGin7RXtU1tbq/LycubhAMzCOZiFczAL5ygpKeny27AVN263Wz6f74Lj1dXV8ng8F10nfRY0XxQfH6/Nmzfro48+0qhRo+xspUVoaKjCwsLatRadj3k4B7NwDmbhHMyi53X1S1KSzROKY2JiLji3xufzqbKyUjExMW2u+9a3vnXR662vr7ezDQAAgDbZipvExEQVFxfL6/W2HNu3b58CAgKUkJDQ5rohQ4Zo5MiRKi4ubnW8uLhYISEhXxk/AAAAl8pW3KSmpio8PFyZmZnav3+/nn/+eWVnZys1NbXVZ9ykpaUpKSmp1dqsrCz9/ve/1wMPPKCioiJt3rxZ27Zt08KFC3mKEAAAdBpb59x4PB7l5eVp5cqVyszMVHh4uObNm6esrKxWl/P7/Wpqamp17Prrr9f69ev129/+Vtu3b1f//v115513avHixR2/FwAAAP/P9rulYmNjlZube9HL5Ofnf+nxWbNmadasWXZvEgAA4JLxW8EBAIBRiBsAAGAU4gYAABiFuAEAAEYhbgAAgFGIGwAAYBTiBgAAGIW4AQAARiFuAACAUYgbAABgFOIGAAAYhbgBAABGIW4AAIBRiBsAAGAU4gYAABiFuAEAAEYhbgAAgFGIGwAAYBTiBgAAGIW4AQAARiFuAACAUYgbAABgFOIGAAAYhbgBAABGIW4AAIBRiBsAAGAU4gYAABiFuAEAAEYhbgAAgFGIGwAAYBTiBgAAGIW4AQAARiFuAACAUYgbAABgFOIGAAAYhbgBAABGIW4AAIBRiBsAAGAU4gYAABiFuAEAAEYhbgAAgFGIGwAAYBTiBgAAGIW4AQAARiFuAACAUYgbAABgFOIGAAAYhbgBAABGIW4AAIBRiBsAAGAU4gYAABiFuAEAAEYhbgAAgFGIGwAAYBTiBgAAGIW4AQAARiFuAACAUYgbAABgFOIGAAAYhbgBAABGIW4AAIBRbMdNaWmp0tPTNW7cOCUkJCg7O1sNDQ22riM3N1ejRo1SRkaG3ZsHAAC4qEA7F66urlZaWpqio6OVk5OjiooKrVmzRnV1dVq2bNklXUdlZaU2bdqkK664ol0bBgAAuBhbcbNjxw7V1NRo48aN6tu3rySpqalJK1asUEZGhgYMGPCV17Fu3Tpdf/31OnXqVLs2DAAAcDG2XpYqLCxUfHx8S9hIUnJysvx+v4qKir5y/VtvvaVXXnlF99xzj+2NAgAAXApbz9yUlZUpJSWl1TG3262oqCiVlZVddG1TU5NWrlypf/qnf1L//v3t77QNtbW1nXZdaL/mOTCPnscsnINZOAezcA7LsuRyubr0NmzFjdfrldvtvuC4x+NRdXX1Rdc+88wzqq2t1cKFC21t8KuUl5d36vWhY5iHczAL52AWzsEsnCE4OLhLr99W3LRXVVWVNmzYoLVr13b6HYqOjlZoaGinXifsq62tVXl5OfNwAGbhHMzCOZiFc5SUlHT5bdiKG7fbLZ/Pd8Hx6upqeTyeNtf95je/0ahRozRx4kR5vV5J0vnz53X+/Hl5vV6FhYUpMLB9nRUaGqqwsLB2rUXnYx7OwSycg1k4B7PoeV39kpRkM25iYmIuOLfG5/OpsrJSMTExba47duyY3nzzTcXFxV3w7+Li4rRlyxYlJiba2QoAAMCXshU3iYmJ2rx5c6tzb/bt26eAgAAlJCS0ue6+++5recam2erVqxUSEqIlS5Zo1KhR7dg6AADAhWzFTWpqqvLz85WZmamMjAxVVFQoOztbqamprT7jJi0tTadOnVJBQYEkafTo0Rdcl9vtVlhYmCZPntzBuwAAAPA5W59z4/F4lJeXp169eikzM1MPP/yw5s2bp6VLl7a6nN/vV1NTU6duFAAA4FLYPos3NjZWubm5F71Mfn7+V17PpVwGAADALn4rOAAAMApxAwAAjELcAAAAoxA3AADAKMQNAAAwCnEDAACMQtwAAACjEDcAAMAoxA0AADAKcQMAAIxC3AAAAKMQNwAAwCjEDQAAMApxAwAAjELcAAAAoxA3AADAKMQNAAAwCnEDAACMQtwAAACjEDcAAMAoxA0AADAKcQMAAIxC3AAAAKMQNwAAwCjEDQAAMApxAwAAjELcAAAAoxA3AADAKMQNAAAwCnEDAACMQtwAAACjEDcAAMAoxA0AADAKcQMAAIxC3AAAAKMQNwAAwCjEDQAAMApxAwAAjELcAAAAoxA3AADAKMQNAAAwCnEDAACMQtwAAACjEDcAAMAoxA0AADAKcQMAAIxC3AAAAKMQNwAAwCjEDQAAMApxAwAAjELcAAAAoxA3AADAKMQNAAAwCnEDAACMQtwAAACjEDcAAMAoxA0AADAKcQMAAIxC3AAAAKMQNwAAwCjEDQAAMEqg3QWlpaVatWqV3n33XYWHh2v27Nn66U9/quDg4DbXnD59Wrm5uSoqKtLx48fVp08fxcXFacmSJRoyZEiH7gAAAMAX2Yqb6upqpaWlKTo6Wjk5OaqoqNCaNWtUV1enZcuWtbnugw8+UEFBgVJSUjR27Fh9+umnevTRR3XLLbdoz549ioyM7PAdAQAAkGzGzY4dO1RTU6ONGzeqb9++kqSmpiatWLFCGRkZGjBgwJeumzBhgvbu3avAwM9vbvz48Zo2bZp27dqlRYsWtf8eAAAAfIGtc24KCwsVHx/fEjaSlJycLL/fr6KiojbXud3uVmEjSQMHDlRkZKROnz5tb8cAAAAXYeuZm7KyMqWkpLQ65na7FRUVpbKyMls3fOzYMVVVVSk2NtbWur9XW1vbofXoHM1zYB49j1k4B7NwDmbhHJZlyeVydelt2Iobr9crt9t9wXGPx6Pq6upLvh7LsrRq1Sr1799fN910k50tXKC8vLxD69G5mIdzMAvnYBbOwSyc4WJvQuoMtt8t1RlycnJ08OBBPfHEEwoLC+vQdUVHRys0NLSTdob2qq2tVXl5OfNwAGbhHMzCOZiFc5SUlHT5bdiKG7fbLZ/Pd8Hx6upqeTyeS7qO5557Tps2bdIDDzyg+Ph4Ozf/pUJDQzscSOg8zMM5mIVzMAvnYBY9r6tfkpJsnlAcExNzwbk1Pp9PlZWViomJ+cr1BQUFWr58ue666y7NmzfP3k4BAAAuga24SUxMVHFxsbxeb8uxffv2KSAgQAkJCRdd+8Ybb2jJkiW65ZZblJmZ2b7dAgAAfAVbcZOamqrw8HBlZmZq//79ev7555Wdna3U1NRWn3GTlpampKSklq9LS0uVmZmp6OhozZ49W++9917L/44fP9559wYAAFz2bJ1z4/F4lJeXp5UrVyozM1Ph4eGaN2+esrKyWl3O7/erqamp5etDhw7J5/PJ5/Np/vz5rS578803a82aNR24CwAAAJ+z/W6p2NhY5ebmXvQy+fn5rb6eO3eu5s6da/emAAAAbOO3ggMAAKMQNwAAwCjEDQAAMApxAwAAjELcAAAAoxA3AADAKMQNAAAwCnEDAACMQtwAAACjEDcAAMAoxA0AADAKcQMAAIxC3AAAAKMQNwAAwCjEDQAAMApxAwAAjELcAAAAoxA3AADAKMQNAAAwCnEDAACMQtwAAACjEDcAAMAoxA0AADAKcQMAAIxC3AAAAKMQNwAAwCjEDQAAMApxAwAAjELcAAAAoxA3AADAKMQNAAAwCnEDAACMQtwAAACjEDcAAMAoxA0AADAKcQMAAIxC3AAAAKMQNwAAwCjEDQAAMApxAwAAjELcAAAAoxA3AADAKMQNAAAwCnEDAACMQtwAAACjEDcAAMAoxA0AADAKcQMAAIxC3AAAAKMQNwAAwCjEDQAAMApxAwAAjELcAAAAoxA3AADAKMQNAAAwCnEDAACMQtwAAACjEDcAAMAoxA0AADAKcQMAAIxC3AAAAKPYjpvS0lKlp6dr3LhxSkhIUHZ2thoaGr5ynWVZevzxxzVt2jSNGTNGt956q95777327BkAAKBNtuKmurpaaWlpamxsVE5OjrKysvTcc89pzZo1X7l2y5Yt2rBhgxYuXKjHHntMUVFRWrRokU6cONHuzQMAAPy9QDsX3rFjh2pqarRx40b17dtXktTU1KQVK1YoIyNDAwYM+NJ19fX1euyxx7Ro0SItXLhQkjRhwgTdeOON2rp1q5YvX96R+wAAANDC1jM3hYWFio+PbwkbSUpOTpbf71dRUVGb69555x2dPXtWycnJLceCg4OVlJSkwsJC+7sGAABog61nbsrKypSSktLqmNvtVlRUlMrKyi66TpJiYmJaHY+NjVVeXp7q6uoUEhJiZytqbGyUJJWUlMjlctlai85nWZYk5uEEzMI5mIVzMAvnaGxs7PIZ2Iobr9crt9t9wXGPx6Pq6uqLrgsODlbv3r1bHXe73bIsS9XV1bbjpvkbExDAG76cwOVyKTg4uKe3ATELJ2EWzsEsnMPlcjkrbpzk6quv7uktAAAAB7L1tIfb7ZbP57vgeHV1tTwez0XXNTQ0qL6+vtVxr9crl8t10bUAAAB22IqbmJiYC86t8fl8qqysvOB8mr9fJ0nHjh1rdbysrEyDBw+2/ZIUAABAW2zFTWJiooqLi+X1eluO7du3TwEBAUpISGhz3fjx4xUREaG9e/e2HGtsbNTLL7+sxMTEdmwbAADgy9k65yY1NVX5+fnKzMxURkaGKioqlJ2drdTU1FafcZOWlqZTp06poKBAktS7d29lZGQoJydHkZGRGjlypLZv366//e1v+vGPf9y59wgAAFzWbMWNx+NRXl6eVq5cqczMTIWHh2vevHnKyspqdTm/36+mpqZWx37yk5/Isixt27ZNn3zyiUaPHq2tW7dq2LBhHb8XAAAA/89lNb/5HwAAwAB8SAwAADAKcQMAAIxC3AAAAKMQNwAAwCjEDQAAMApxAwAAjELcAJcRv9/f01uApPPnz0uS+CQOZ2AO5jEmbs6dO3fBBweiZzQ0NPT0FvAFp0+f1p49eyRJAQHG/Mh/LVVUVOiRRx7RSy+9JL/fL5fL1dNbumx5vV6dPHmSORjK1icUO9XatWtVWFioqKgoxcXFKSUlRQMHDpTf7+fBvJtt2rRJhw8fVmhoqOLi4jR79mxFRET09LYuW2VlZUpJSVFQUJCuuOIKxcfH83PRQzZs2KCtW7dq9OjR6tOnjyorK1v92hp0n3Xr1umll15ScHCwhgwZottuu02JiYn8bPSQnTt3qn///ho2bFjLL9q2LKtD0fm1jhufz6d/+7d/09GjR3XzzTfrxIkTys3N1cGDB7V69WoNGzasw98gXJoDBw5o+fLlCg0N1YQJE3T06FGtXLlS5eXluuuuu9SnT5+e3uJl6eOPP1Ztba2io6O1c+dOTZw4UUFBQfxcdLO9e/fqpZde0qpVqxQXF6dvfOMb6t27d09v67Lz8ccf67777lNVVZXS09NVU1Oj3bt366GHHtLIkSM1cODAnt7iZaWwsFBLly5V79695ff7VVNTo8WLFys9Pb3Dj1Nf67g5efKk3njjDT344IO6/vrrJUnXXnutNm3apPvuu0/5+fk8gHeD8vJybdiwQXFxcbrjjjvUv39/BQUF6cEHH9TevXt1/fXXKz4+vqe3eVnq16+f4uLiNGjQIB06dEh79uzRzTff3NPbuqw0NDToP/7jPzRhwgTNmDFDoaGhLceDg4N7eHeXl0OHDqmkpETr16/XxIkT5XK5NHz4cK1bt07l5eXETTeqqanRtm3blJSUpIyMDIWEhGjTpk165pln9Omnn+ree+/t0PV/rZ9/KykpUVBQkL75zW+2HJs2bZoWL16sd955R88884wkThbrarW1tQoKCtLs2bM1ZMgQBQUFSfrsl6VWVlbK5/P18A4vXyUlJZKkn/3sZ4qIiNDu3btVWVkpl8vFycXdxOVyyev1asqUKQoNDVVVVZVWrlypZcuWaceOHTpx4oQkHqe6Q1FRkcLCwvStb32r5S++Q4cOlc/n05AhQ1ouxyy63l/+8hcdPnxYcXFxGjx4sCIjI3XnnXdq3rx5evLJJ/Xmm2926MmJr2XcNP+HN2jQIJ05c0a1tbWSpKamJgUFBenaa69VSkqKNm7cqNraWp696WLDhw9XTk6O4uLiWh2vq6tTRESEvF5vD+0Mw4cP1yeffKLIyEjNmTNHx48f186dOyVxcnF3qaqqUk1Njerq6vTKK69o5syZOnTokE6cOKFHHnlEt99+u7xeL49TXag55K+99lp99NFHevvtt3Xu3DlJUn5+vmJjY/Xyyy/r0KFDksQsuoHP55Pf728578zv96tv376aO3eurrnmGj3wwAMdisyv5aNb8394sbGxGjZsWMuDdfM3ok+fPkpJSVFjY6OefPJJSbwFtiuFhYXJ4/G0fP+b/1lfXy+fz6cRI0b05PYua8ePH1dAQIB69eqlm2++WSNGjNCrr76qo0eP6vDhw6qqqurpLRrNsiwNHDhQgwYNUkFBgf74xz9qzpw52rp1q3Jzc5WTk6O6ujr96le/Un19fU9v11jNIZ+UlKQZM2bo/vvv15133qlJkybp4MGDio6O1tNPP6077rhDmzdvlsSfGV1t7NixCg8P1x//+EdJanm38+DBg7Vw4UKVlJRo9+7dkto3C8fGzaW8rTs0NFSzZs3SCy+8oJMnTyowMFCNjY2SpBEjRmjmzJl6+eWXVVdXx99SO+BS32LfHJ3N//zf//1f9evXT0OHDu2yvV2OLmUezYHZv39/uVwuVVRUKCIiQunp6aqoqND8+fO1aNEiVVVV8RR8B3zVLJp/Fm655RYVFhbqqaee0tSpU+XxeBQUFKQJEyYoKytLe/bs0V/+8pfu2LKxLvVxav369Xr22WcVGRmpq6++Ws8++6xWr16t3/3ud5o1a5Y2btyoTz75hD8zOsHFosTv92vGjBl66qmnWl51aZ7hVVddpe9+97vaunWrpPY9y+y46Z07d05r167VihUrtH37dn300UdtXjYkJESJiYkaMmSIVq1aJUkKDAyUZVlyu90aPny46uvreVmknezM4sscP35ckZGR+sY3vtFyjD9I28/OPJr/UD1+/LgkacCAAaqoqNBzzz2niooKuVwu/fM//7NGjhzJTNrB7s/GuHHjlJiYKEktL6NblqWAgACNGzdOkZGRKioq6vJ9m8juLIKCguR2u3X48GElJye3vCwSGRmpG2+8UeHh4fqf//mf7ti6kWpra5WXl6fGxkYFBAS0+fjSu3fvljcCrV+/vtW/i4yM1IQJE3Tu3Dm9//777dqHo+Lmrbfe0syZM/XOO++ooqJCjz76qBYtWqSSkpI2v0FjxozR/Pnz9Yc//EEvvviiXC5XywN7RESEPv74Y96R0A5tzeLPf/7zJf9h+MYbb+jb3/62goODdf78eR09elR5eXk6ffp0F+/ePHZ/NpqPDRw4UEFBQfrlL3+ppKQk/fWvf9W9996rgQMH6r333lN9fT1/Q7WpPY9T3/zmNzV37lyFhoZq//79On36dMvj1JkzZ+T1elud0IpL055ZuFwunT9/XhUVFS0fUdH8jMG5c+fk8/nUv3//brsPJikoKFBSUpIefPBB5eXlSfryv9A2H7v66qv1/e9/X7m5uSorK1OvXr1anu35zne+o4qKCvXt27dde3HUo1pBQYGio6O1adMmbdy4UU8//bTCwsK0dOlSvf3225Jaf6Msy1JQUJBmzZqluXPn6t///d+1e/dunTlzRhUVFfrDH/6gWbNmtfubczlraxa/+MUvvnQWf6+qqkpHjx7V+PHj5fV6tWnTJs2ZM0eFhYUKDPxafwJBj7D7s9H8B2dNTY2OHTum4uJiLVmyRL/97W+Vnp6uqVOn6sCBAyouLu6R+/N1ZncW0mdPq1933XVavHixdu3apSeffFLl5eU6duyY9uzZoyuvvFLf+c53euLufK21ZxbNxowZo4cfflh1dXWqra3VqVOn9N///d+aMGGCRo8e3Z13wwgHDx5Udna2hg4dqvHjx+uFF17QX//6VwUEBFzw8lTz45Pb7dbcuXM1atQo/fznP2+5vCQdOXJEUVFR7f/Ll+Ug1113nbV+/fpWx0pLS62pU6daP/vZz6wzZ85YlmVZfr+/1T+b/39mZqY1efJk64YbbrBmzJhhTZ8+3Xr77be77w4YxO4s/t6HH35oTZo0yfrlL39p3XTTTdaUKVOsXbt2dfm+TdWRn419+/ZZpaWlVlNTU8uxyspK68033+yGnZunoz8ba9eutaZPn27Fx8db1113nTV16lTr1Vdf7fJ9m6gjPxevvPKKlZCQYE2ZMsVatGiRNWvWLGv69OlWcXFx990Bg7z++uvWggULrCNHjlgFBQXWzJkzrWXLln3lOr/fb/3pT3+yJk2aZM2bN896+OGHrWeffdaaNm2atXz58jZ/jr6KY/4Kff78eQ0bNqzlHAHps6cKY2JidNttt+nZZ59VQUGBUlNTWz6jo7nomv//2rVrdfToUb3//vsKDAzUrbfe2lN352utI7NoduLECVVXV2vnzp1KT0/Xv/7rv3b33TBGR+cxY8YM9erVq+Vry7LUr18/9evXr1vvhwk643Hqnnvu0Q9/+EOVlpaqpqZGs2bN6qm787XW0Z+L7373uxoyZIhefPFFVVVVKTExUWlpaT1xV4wwefJkTZ06VdJnH0FRWFio1157TW+99ZYmTpyopqamVo9DzV9blqWrrrpKW7Zs0e9+9zsVFhbq3Llz+sd//EdlZWW1ez+OeVkqMDBQV155pSoqKnT06FFJnz+duHDhQnk8Hr3++uuqqKiQ9PnZ0/v37295iiskJERjx47Vj370I8KmAzoyi+bL9evXT3fffbf2799P2HRQR+fR/ADSjM/waL/OeJySPvvguOuuu46w6YDOeJy68sordc8992jVqlWETQc1f3hrQ0ODevfure9///uKjIzUli1bJKlV2Hzx6+a5jBkzRr/61a+0bds27dq1q0NhIzkobiTp9ttv1wcffKA333xTlmW1vLU7ODhY8+fP14EDB1RZWdly+aefflq33367fvOb30i68JuH9mvvLB555BFJn32GwR133NHqnVJov47+bBA0nYfHKefo6CyacVJ952l+A09cXJymT5+uDz/8ULt27ZL02bNtzU6cOKH09PSWz7Jp/neRkZEKCwvr8D4cNdEBAwZozpw52rlzp44cOSLp8//oZs+eLcuy9OGHH7ZcftKkSYqPj9fYsWN7ZL8ma+8sxo0b1+qy6Bz8bDgHs3AOZuFMzScQ33TTTYqJiVF+fr5qa2sVGBjY8s60kydP6sCBA9qzZ48kdf4bTdp1pk4XOnfunHXVVVdZq1evtj799NOW41VVVdbMmTOtRx991LKstk/WQ+dhFs7CPJyDWTgHs3C2Z555xpo+fbqVk5NjWdZnJ3J/+OGHlmVZVlFRUZfdruP+eh0aGqp169bp97//vZ544glJn514VFZWpnPnzmnixImSeJq9OzALZ2EezsEsnINZONMXn70ZO3asXnjhBS1evFiZmZkqLCyUJF1zzTVddvuOebfUF91www3685//rMcff1wHDx7Ut7/9be3fv19XXXWVYmNjZVkW/6F2E2bhLMzDOZiFczAL5wkICFBDQ4POnj2r8+fP69SpU4qIiNDjjz/e8mndXcllWc797PXXX39dr7/+uo4fP66pU6dqwYIFPb2lyxazcBbm4RzMwjmYhbOUlpZqwYIFqqur089//nPNnz+/227b0XHTjOp2DmbhLMzDOZiFczALZ2hoaFBeXp5uu+02hYSEdOttfy3iBgAA4FI57oRiAACAjiBuAACAUYgbAABgFOIGAAAYhbgBAABGIW4AAIBRiBsAAGAU4gYAABiFuAEAAEYhbgAAgFGIGwAAYJT/Axx9jCLgaCoWAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 860.25x500 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.stack(mse_list, axis=0),\n",
    "        'methods':category,\n",
    "        'prediction years':pred_len}\n",
    "print(mse_list)\n",
    "data = pd.DataFrame.from_dict(data)\n",
    "sns.set(style=\"whitegrid\")\n",
    "plt.xticks(rotation=30)\n",
    "\n",
    "color_palette = [ \"#6F99B4\", \"#1F77B4\", \"#FFBA7E\",\"#FF7F0E\", \"#90D7A3\",  \"#2CA02C\",\"#FF9693\", \"#FF0000\"][::-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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.19842117, 0.19842117, 0.19537379, 0.19537379, 0.13300127, 0.13300127, 0.19370107, 0.19370107, 0.20217308, 0.20428388, 0.19665544, 0.19752799, 0.13389565, 0.13388738, 0.19881311, 0.20496112, 0.20551196, 0.20853694, 0.20266944, 0.20524183, 0.13760743, 0.13821809, 0.20248224, 0.21483114]\n"
     ]
    },
    {
     "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 860.25x500 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.stack(mae_list, axis=0),\n",
    "        'methods':category,\n",
    "        'prediction years':pred_len}\n",
    "print(mae_list)\n",
    "data = pd.DataFrame.from_dict(data)\n",
    "sns.set(style=\"whitegrid\")\n",
    "plt.xticks(rotation=30)\n",
    "color_palette = [ \"#6F99B4\", \"#1F77B4\", \"#FFBA7E\",\"#FF7F0E\", \"#90D7A3\",  \"#2CA02C\",\"#FF9693\", \"#FF0000\"][::-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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tmp = np.array(mae_list[8:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.0104406  1.004437   0.99993825 1.0309236  1.0147192  1.0126926\n",
      " 1.0044377  1.0609876 ]\n",
      "[0.19842117, 0.19842117, 0.19537379, 0.19537379, 0.13300127, 0.13300127, 0.19370107, 0.19370107, 0.20217308, 0.20428388, 0.19665544, 0.19752799, 0.13389565, 0.13388738, 0.19881311, 0.20496112, 0.20551196, 0.20853694, 0.20266944, 0.20524183, 0.13760743, 0.13821809, 0.20248224, 0.21483114]\n"
     ]
    }
   ],
   "source": [
    "print(tmp[1::2]/tmp[0::2])\n",
    "print(mae_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mae_baseline = [0.29741377, 0.24866816, 0.15656155, 0.23034102, 0.30123833, 0.25227037, 0.16764102715290105,0.23470001]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.31313241 0.20565629 0.14482591 0.11018402 0.30773438 0.18642118\n",
      " 0.17551155 0.08465644]\n"
     ]
    }
   ],
   "source": [
    "print(1-tmp[1::2]/mae_baseline)"
   ]
  }
 ],
 "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
}